Lambda the Ultimate

Is it just me? Or is the LtU forum usability suboptimal? When discussions grow moderately large i find it almost impossible to keep track and I generally give up reading the threads.

I don't watch the forum all they. I generally just drop by a few times a day to see what's new. Discussions tend to diverge into a few different threads, some of which are more interesting than others. Based on this I have two basic needs. I need to be able to easily see which threads have new posts in them, and I would like to browse the threads separately, like I would if it was a usenet group.

Currently I can easily see which threads have new posts, but because of the way this is implemented I have to search for the string "***" to find the new entries. In addition it's very hard to keep track of the various sub-threads. The way the threads are indented is also not very good. I appreciate the idea, but when threads get really deep readability suffers.

IMO the ideal solution would be a threaded forum that has a two-pane solution where the threads are in one pane and the currently active message are in the other. Topics should be ordered according to the latest post, and each discussion should mark clearly if it contains new posts. When you expand a thread, it should be possible to see which thread(s) contain new posts, and expand just that thread. It would also be cool if you could "flatten" a thread at arbitrary level, if you wish to view many articles simultaneously in the view pane.

I don't know about what web forums are available, but the ones that seem to be most popular also seem to be the simplest. They all offer a flat model without threading, which IMO sucks.

Am I alone in thinking that the LtU forum is in dire need of an upgrade? And does anyone know about *good* forums that meet the criteria I have listed?

(note the complementary thread)

Given an imperatively styled program in C, with complex shared state, how would people suggest converting it to functional style?

The program I'm working with is Chromium, which implements a stream-processing model over the OpenGL API, so that the calls from a graphics program (e.g. Quake) get turned into a stream of function calls that can be filtered/modified.

To do this, Chromium contains a "state machine" which tracks all state contained in OpenGL: lighting, raster-position, textures, matrix-stacks, etc. etc.

Via google I found HOGL, a functionalish Haskell binding for OpenGL that lets you do things like:

demo0 = runGraphics ( do
    w <- openWindow "Demo 0" (400, 400)
    print "Demo0 a very simple Hogl program"
    print "press any key to quit"
    draw w (WithColor blue
            (Translate (0,0,-50)
             (Scale (80,80,80)
              (Rotate 36 (1,1,0)
               (cube 1)))))
    getKey w
    closeWindow w
    )

- that is, you can do some state-changes (here setting the current color and changing the modelview matrix) in a functional style.

..anyway, how would people suggest to deal with a large state-machine like that in OpenGL? Are there tools out there for semi-automation of the process?