Arc gets I/O right

In any significant program, a great deal of code is spent on two activities that have very little intrinsic interest: I/O and error handling. This makes them good targets for language design. If a language can make these two areas easier, it can remove a significant part of the accidental complexity of programs. Conversely, a language in which either is difficult is a language in which effort is wasted on uninteresting problems.

This is where Arc is good. Many parts of it are hacky or just not there yet, but its I/O library is strikingly convenient. There's a lot there worth seeing and maybe stealing. In particular:

  • The whole-file I/O routines, starting with readfile, are a great idea - usually what you want in a file is to read the whole thing. There should be one (file?) for reading the whole file as a string too. (The point here is not that they read the whole file in one piece, but that they handle the opening and closing - all they need is the filename.)
  • infile and outfile are nice and simple. Opening files for reading and writing are quite different operations, and there's no reason to do both with the same function. Getting rid of the mode argument also makes the functions easier to compose. This can go further: the remaining binary, text and append arguments should be separate functions too.
  • Using tostring is much simpler than having an optional stream argument to every output routine. For instance, (tostring (prall thingies "We have ") (when (no done?) (pr " and more coming!"))). Dynamic variables are a perfectly reasonable way to pass arguments, especially those like streams that tend to be used in dynamic scope - so why don't I feel good about this? Are there any cases it handles badly?
  • Printing several values separated by spaces is a common operation (especially in throwaway programs) but it needs a good name. I like prs better than what I was using (prv, for "print values") although it might conflict with other functions like "print to stream".
  • prall is another function I often want, although it feels unwieldy to me, possibly because the second argument is printed before the first. The prefix argument also seems out of place.
  • prf is (format t ...), plus it does string interpolation in case you prefer that. Where's the non-printing format (well, probably fmt in Arc)? This is definitely common enough to deserve a function, not just (tostring (prf ...)).
  • There are some other perlesque string operations - tokens and such. You can never have enough of these (even in Perl).
  • I'm not sure if w/bars is useful (for what, debugging?) but it's an interesting kind of output wrapper - it captures write operations, not characters. How about a similar wrapper that indents every line?
  • It's not an I/O routine, but ellipsize handles a common problem (truncating long strings and adding an ellipsis) that would often go unhandled without it.

I/O is really a subset of a more general category, glue, which probably accounts for more complexity than everything else put together. And it's all accidental complexity, so it should be a target for libraries. Unfortunately I don't think there are any general ways to reduce it, because there are so many different transformations that have to be done. But simplifying I/O addresses the most common kind of glue. Remarkably, considering its age and importance, this area is not solved. There are still considerable improvements to be found, and Arc is finding some of them.

I wish I could find similar improvements in error handling.

3 comments:

  1. Check out REBOL as well. http://www.rebol.com/index-lang.html

    They get a lot of this kind of stuff right as well-- the small language details that add up to a simpler and more enjoyable experience.

    ReplyDelete
  2. I wish I could find similar improvements in error handling.

    Are you familiar with Erlang's supervisory trees?

    ReplyDelete
  3. I know about Erlang exit signals (although I have no idea how they work in practice), but not about supervision trees. Reading... it looks like they address the problem of recovering after an error, which is something I (unwisely?) don't usually worry about. The sort of error handling I was thinking of is the more mundane problem of expressing which handler to call after an error is detected. I think it should be possible to improve on the ML-style exceptions most modern languages use, but I haven't been able to do so. I should do a post about this.

    My favorite part of Erlang's error handling isn't the multiprocess stuff, but the way it catches exceptions by plain old pattern matching - like ML, but without having to break the rules of the language. (ML exceptions are an open sum type, which ML doesn't otherwise support.) It's also nice that (IIUC) you don't have to declare them first, since anything that increases the effort required to signal an error is likely to discourage programmers from even checking for the error.

    ReplyDelete

It's OK to comment on old posts.