2012/05/11

Release timing

I finally pushed Gauche 0.9.3 out of door the day before yesterday---something I've been thinking I'd get to do "soon" for the last few months. There hasn't been big changes for a while and I thought it was quite stable and ready.

The day after the release, I found that I couldn't build git HEAD with 0.9.3 on Windows. Damn. I have Jenkins running on Linux that checks self-build, but the bug was in Windows-specific code. It doesn't affect ordinary users who just install Gauche (building from a release tarball is just fine), but it's inconvenient for developers, so I quickly wrap the fixed version as 0.9.3.1.

The day after that, somebody notified about a build failure if Gauche is configured with sjis or eucjp character encoding. I introduced the bug when I supported out-of-tree build but it did't affect utf-8 build. I pondered whether I'd just say "apply this patch if you want sjis/eucjp Gauche". But well, I've just went through packaging process so many times (including testing), it's just as easy to make another release---0.9.3.2.

I feel that the difficulty of releasing mostly comes from the fact that I'm not used to it enough. If it were everyday thing, I'd just "know" what to do and could avoid the pitfalls almost unconsciously. With the pace of one release in several months, however, I need to go through details consciously, keep checking if I'm not missing anything. That's a lot of mental burden.

It seems that there's a "release admittance" parameter, which increases if you know the process well but decreases as the time passes. The parameter is maximum when you've just went thorough the process. ("Admittance" is EE jargon: It's a reciprocal of impedance. It shows how easy the release process is.)

Releasing 0.9.3.1 and 0.9.3.2 were so easy since my release admittance was still high.

On the other hand, there's a "release pressure"; as the time passes and unreleased changes accumulates, the pressure increases.

(I think the pressure gradually saturates, since if there are already so many unreleased changes, the relative importance of one more unreleased change decreases. I suspect this curve actually decreases if I extend it further---if there's no releases for years and everybody you know has started using git HEAD, you won't feel much pressure for the next release.)

I always feel I've waited too long for a new release; the release happens when I couldn't hold the pressure any longer, but at the time my admittance gets too low and I have to plow through the process against high resistance.

Probably the optimum time of release is the peak of Y*P.

That is, when the pressure and easiness gets well balanced.

My feeling is that it is somewhere between 1-3 months after the release. I aim at that range for 0.9.4 (crossing fingers).

Tags: 0.9.3, release

2012/03/18

Consumers for generators

I've been trying out generators for day-to-day scripts and have repeatedly seen a common pattern--- to repeat reading from a generator and process values until it is exhausted. I wrote a bunch of utilities in gauche.generator but they are mostly a sort of filters, taking generators and yielding another generator. What I needed is a kind of "terminator" of the chain of generators, where the generated values were actually consumed.

Since a generator is just a thunk, I can use already existing tools---actually, port-fold, port-map and port-for-each expect thunks (in spite of their names), and we can pass a generator directly.

(port-for-each (^v ...) generator-expr)

Probably I should rename them to indicate they are actually about generators, not ports.

(Another option is to convert a generator to a lazy sequence by generator->lseq, so that we can use all list-handling utilities without wasting space for intermediate lists. But it still has some overhead (not only CPU-wise, but mentally for programmers who read and write the code). So I think it makes sense to have specialized utilities for generators.)

For lists, we have for-each. But sometimes it is handy and more readable to use dolist macro, taken from CL. We can have its equivalent for generators:

(do-generator [v generator-expr]
  ... do something with v ...)

What if we want to run across multiple generators, or even to mix generators and other sequences? Instead of inventing more macros, we can extend the existing srfi-42 mechanism to handle generators.

(do-ec (:parallel (: x '(a b c))
                  (: y (gdrop-while skip-preamble
                                    (file->generator "foo"))))
  (do-something x y))

For the latter, we added :generator EC-qualifier (so the second clause of :parallel in the above example can also be written as (:generator y ...)). The generic dispatcher of : dispatches to the :generator if its argument is an applicable entity taking zero arguments.

Those changes have been pushed to the master.

Tags: Generator, gauche.generator, srfi-42

2012/02/08

Threads, build process, lazy sequences

Haven't updated this blog for a while (again). Here's a quick progress report.

Windows threads

On Windows/MinGW, threads are finally supported. It uses Windows thread (not pthread-win32.) Configure with --enable-threads=win32 on MinGW&MSYS environment.

  ./configure --enable-threads=win32

By 0.9.2, you might have checked the availability of threads by gauche.sys.pthreads feature identifier in cond-expand. This feature identifier isn't available on Windows threads build. We created a new feature identifier, gauche.sys.threads, which is defined in both pthreads build and Windows threads build, and suitable for the Scheme programs that wants to switch behavior based on the availability of threads.

  (cond-expand
    [gauche.sys.threads
      ... code using threads ...]
    [else
      ... code not using threads ...])

The feature id gauche.sys.pthreads is still available on pthreads build, and a new feature id gauche.sys.wthreads is available on Windows threads build, in case if you need finer distinction of the thread library (but there's hardly visible difference in Scheme level).

Better thread safety

Kirill Zorin is using Gauche in a way that is a good stress test for Gauche's thread support, and he has identified and fixed numerous thread-related bugs. Thanks, Kirill! I won't surprise if we find more, but I'm quite happy about the improvement.

Out-of-source-tree build

In the very early stage, we made it so that Gauche can be build in separate directory from the source tree, but it has been broken since then. It's not trivial to fix since Gauche needs multi-stage build, that is, one process generates a source file to be compiled, and running the compiled one generates another source file, and so on. Now I finsished updating various *.in files so that it could compile out of source tree again.

To build in a different directory, just call the 'configure' script of the source tree from the build directory, e.g.

  $ ls
  Gauche
  $ mkdir Gauche-build
  $ cd Gauche-build
  $ ../Gauche/configure
  $ make

Lazy sequences

Finally documented lazy sequences and generators. Check out the chapter of "Lazy evaluation", and also "gauche.sequence" and "gauche.lazy" modules.

Tags: Threads, gauche.lazy, gauche.sequence

2011/12/27

Gc update

The development HEAD now uses bdwgc 7.2alpha6.

It is working on Linux, MinGW and MaxOSX, but a problem is reported on NetBSD.

I want to ship 0.9.3 with this version of gc, but I'll backport some of more recent fixes in gc whenever needed.

It is said that Windows thread support on MinGW is much improved in this gc version, so I'm also trying to make threads available on Gauche/MinGW.

Tags: 0.9.3, gc

2011/12/12

Action items for 0.9.3

I wish I could write solid articles explaining upcoming features one by one, but if I wait for having enough time to do so, it's not likely to happen in near future. So I just write this down as a casual memorandum.

There are three features I definitely want to put in; the first two are already coded and working, but lack documentation (and it is often the case that I find better ideas and/or flaws while writing the docs, so in a sense they're just half way through.) The third one is working on Linux but needs some more work to make sure it work on other platforms:

• Generators: gauche.generator module provides generic operations on generators, a thunk that yields a value at a time. For example, read-char works as a generator (if we call it without arguments). We can have operations like filter, take, drop, append, zip, etc. on those generators. The places where generators themselves are useful may be limited, but they are basis of the lazy sequence, described next.

• Lazy sequence: Yes, Gauche now have a lazy list. From the Scheme code, it just look like an ordinary list, but the list's cdr is calculated as needed. It's different from util.stream, which provides a disjoint type for lazy streams. That is, you can use car/cdr and all other list operations on lazy sequences. In fact, it responds #t to pair?, so you cannot distinguish ordinary lists and lazy sequence.

• TLS/SSL support: In tls branch we have native TLS support working on Linux, using axTLS (thanks to Kirill Zorin). We no longer need to rely on external stunnel process.

Then, here's a list of features I did some work, but not sure 0.9.3 have full of it.

• List library reorganization: I'm tired writing (use srfi-1) in every Gauche code I write. There are already some srfi-1 procedures moved into core, for they are required by the compiler. Until 0.8.3 or so, we needed to keep the set of built-in procedures small, since they needed to be written in C. However, it's been quite some time that we can precompile Scheme procedures and link to libgauche.so, so there's not much reason we need to have useful list procedures into a separate library. I'm moving most srfi-1 list procedures into core (probably I keep list-as-set operations in srfi-1). I'll also revise util.list, for it is just confusing to have a bunch of list libraries.

• PEG parser. It was originally written by Rui Ueyama several years ago, and I heavily modified it to run faster on Gauche. However, I didn't like the way it is optimized---it's ugly. The code has been already in Gauche distribution for some time, and actually rfc.json is written on top of it, but I refrained from making PEG API official. Now, with the lazy sequence support and some advanced optimizations in the compiler, I'm revisiting the PEG parser to make it simple yet efficient. In my local branch it is working, but the performance isn't satisfying. It looks like I have to work more on the compiler to optimize it. 0.9.3 will likely to contain this new code, but I'm not sure I make it official or not.

... and there are plenty of other ideas sitting on the shelf. I started to write them down but it got pretty long so I just keep them for the next time.

Tags: 0.9.3, srfi-1, LazySequence, peg