Peter pulled together some people for sessions to bring 7.8 a little closer, some weeks ago, by forcing people to talk to one another, do some debugging, set up linux on his PS3, have kladdkaka and generally have a good time. I took some notes, and they were briefly circled for validity among participants prior to being completely forgotten. They just surfaced, again, in a spot of enlightened recollection; enjoy!

Order is semi-random, some points already have been implemented since then and where things are difficult to understand, other participants can hopefully give better explanations on request. Conclusions:

* Backend hack: fall back to poll if epoll does not work.

* Remove varargs support (here meaning automatic "|void" decoration of all attributes -- not the trailing "<type> ... args" support).

* Remove all traces of write << "foo" and similar "C++ streams" hacks. (which have not worked since Pike 0.5 or something like that anyway)

* Stuff setting nonblocking mode should first check whether they could before propagating to a backend (select) or not.

* GLUE initialization might be a bit lazier about setting up lights.

* Locale generates deferred call_out:s -- don't, until Locale is used.

* Pike 7.7 split to 7.8/7.9, feature freezing 7.8.

* Mast, grubba and others commit their experiments to 7.7 first.

* Others, feel welcome to mention what you're cooking, estimating when it might be checked in, for same split.

* Attribute no_return.

* Attribute for type checking (sprintf, werror).

* Typedefs are good.

* Turn on features in 7.7 by default which are intended to be deployed in pike 7.8. (This includes the new types and mapping-keypair-loop.)

* Binary Hollerith encoding for sprintf/sscanf (%H, %2H, %-4H et c).

* Add a structured way of reading/writing serialized data.

* Add the function signatures int max(string s) and int min(string s).

* For pike 8.0, add a buffer type (somewhat similar to System.Memory, but as a base type). I/O calls that presently handle string(0..255) should instead use buffer. It should further on be really easy using codecs like Locale.Charset to transition the buffer to/from strings, without much syntactic overhead, so you'd only be using the buffer directly when you're actually working on raw binary data.

* The new compiler also aims for pike 8.0.

* Buffer literals? {[ 17, /* ..., */ "foo", 0xBA ]} might be a syntax.

* Stdio.read_file() shall take one parameter only (a file name), so that it might eventually blend in with the above for handling some additional parameter to specify an encoding. The result might look something like:

buffer read_file( string filename ) string read_file( string fn, string|Locale.Charset.Decoder charset )

* We have rather many different-looking streaming interfaces in Pike; consolidating them to a common naming scheme and possibly leveraging that with features that make sense wouldn't hurt.

* There are lots of include files strewn about the place at random that would benefit from some cleanups.

* It should be possible to build modules separately.

* Add testsuite coverage for pike -x module so breakage there does not fly below radar for extended periods of time.

* grubba checks in the whitefish repository below cvsroot/projects/

* eventually: move out modules so they do not live in pike core

* Math operations on NaN dump core under ix86; fix.

* Add a syntax for type propagation (on the pike level); examples: - a function that returns a type mimicing its first argument - popen can now return file objects -> strict type checks explode