View Tur til Estenstadmarka in a larger map

Today I added an illustration to the Wikipedia page on ploidy:

Haploid vs diploid.svg

Earlier illustrations include (low-res versions, click for full size):

Virtual memory.svg

Alfa beta gamma radiation penetration.svg

The illustrations are drawn with Inkscape and are licensed under a dual CC-BY-SA-3.0 and GFDL licence, as recommended by Wikimedia Commons – so if you want to use them, or improve them, go ahead!

Today I learnt…

…how neural networks (think brains) can do differentiation by using temporal inhibition – i.e. by using a delayed signal. In the figure below, the node α will send a signal to two nodes. One of them – β – will pass on an inhibitory signal of the same strength as its input signal, but with a delay. Thus, when β‘s signal gets sent to the final node, α will at the same time be sending its “next” output signal to the final node.

“Differentiation” by using delayed inhibition. Solid lines indicate excitatory signals and the dotted line an inhibitory signal.

Therefore, the final node will receive two signals: the current output of α and the inverted previous output of α. If the final node sums these together its output will therefore be α‘s current value minus its old value – i.e. positive if α‘s output signal is increasing and negative if it is decreasing. Simple and beautiful!

To correct this embarrassing fact I quickly wrote a version in Haskell using the GLUT bindings.

Conway's Game of Life

It is very simple, but it works.

import Graphics.UI.GLUT hiding (get)
import Graphics.Rendering.GLU.Raw (gluOrtho2D)
import Data.IORef
import System.Random
 
-- dimensions of our cellular space
width  = 80 :: Int
height = 60 :: Int
 
-- takes a two-dimensional list and returns the neighbours of (x,y)
neighbours :: [[a]] -> (Int,Int) -> [a]
neighbours m (x,y) = map (\(x',y') -> m !! y' !! x') $ filter valid neighbours'
    where height'       = length m
          width'        = length (head m)
          valid (x',y') = x' >= 0 && x' < width' && y' >= 0 && y' < height'
          neighbours'   = [(x-1,y-1),(x,y-1),(x+1,y-1), -- neighbours over
                           (x-1,y),(x+1,y),             -- neighbours left/right
                           (x-1,y+1),(x,y+1),(x+1,y+1)] -- neighbours under
 
-- updates all cells according to the rules in liveOrDead
update :: IORef [[Bool]] -> IO ()
update c = do
    cells <- readIORef c
 
    let coords = [(x,y) | y <- [0..(height-1)], x <- [0..(width-1)]]
 
    nextGen <- mapM (\(x,y) -> do
            let cell = cells !! y !! x
            let ns   = neighbours cells (x,y)
            return $ liveOrDead cell ((length . filter id) ns)
        ) coords
 
    writeIORef c (nLists width nextGen)
    display c
 
-- survival rule: a live cell only lives on if it has 2 or 3 live neighbours
-- birth rule: a dead cell becomes a live cell if it has 3 live neighbours
liveOrDead :: Bool -> Int -> Bool
liveOrDead True nLive = nLive `elem` [2,3]
liveOrDead False nLive = nLive == 3
 
-- utility function: split a list into sublists of length n
nLists :: Int -> [a] -> [[a]]
nLists _ [] = []
nLists n ls = take n ls : nLists n (drop n ls)
 
-- utility function: draws a square at (x,y) with size w×h
drawQuad :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
drawQuad x y w h =
    renderPrimitive Quads $ do
        vertex (Vertex3  x     y    0)
        vertex (Vertex3 (x+w)  y    0)
        vertex (Vertex3 (x+w) (y-h) 0)
        vertex (Vertex3  x    (y-h) 0)
 
-- draw each cell as a coloured square
display :: IORef [[Bool]] -> IO ()
display c = do
    cells <- readIORef c
 
    let h = fromIntegral height
    let w = fromIntegral width
 
    mapM_ (\(n,b) -> do
        if b
          then currentColor $= Color4 1.0 0.8 0.6 1.0
          else currentColor $= Color4 0.4 0.5 0.4 1.0
        let x = 1/w*fromIntegral (n `mod` width)
        let y = 1-(1/h*fromIntegral (n `div` width))
        drawQuad x y (1/w) (1/h)
        ) (zip [0..] $ concat cells)
 
    swapBuffers
 
main :: IO ()
main = do
    g <- newStdGen
    _ <- getArgsAndInitialize
 
    -- random starting values
    cells <- newIORef ((nLists width . take (width*height) . randoms) g)
 
    _ <- createWindow "Conway's Game of Life"
    initialDisplayMode    $= [DoubleBuffered]
    windowSize            $= Size 800 600
    displayCallback       $= display cells
    idleCallback          $= Just (update cells)
    gluOrtho2D 0 1 0 1    -- orthogonal projection
    mainLoop              -- start main loop

One of the things I found really interesting was how Douglas Crockford recommended code reading as a way to avoid having confused programmers in a project that aren’t aware of their own situation before it’s too late. According to Crockford it also helps by making sure that the really good programmers mentor other people on their team. The procedure is very simple:

Seibel: Can you talk a bit about how you conduct a code reading?

Crockford: At each meeting, someone’s responsible for reading their code, and they’ll walk us through everything, and the rest of us will observe. It’s a really good chance for the rest of the team to understand how their stuff is going to have to fit with that stuff.

We get everybody around the table; everybody gets a stack of paper. We also blow it up on the screen. And we all read through it together. And we’re all commenting on the code as we go along. People say, “I don’t understand this comment”, or, “This comment doesn’t seem to describe the code.” That kind of stuff can be so valuable because as a programmer you stop reading your own comments and you’re not aware that you’re misdirecting the reader. Having the people you work with helping to keep you code clean is a huge service—you find defects that you never would have found on your own.

I think an hour of code reading is worth two weeks of QA. It’s just a really effective way of removing errors. If you have someone who is strong reading, then the novices around them are going to learn a lot that they wouldn’t be learning otherwise, and if you have a novice reading, he’s going to get a lot of really good advice.

[...]

For one thing it makes it easier to track the project, because we can actually see what progress people are making. And we can see much sooner if they’re going off the rails or not.

I simply loved this idea and would love to test it in practice. I know that I personally would find it highly motivating, both with respect to the quality of my own code and for the project as a whole by so explicitly seeing what the others are doing.

This is probably not going to work for all projects and teams, but for a relatively small team (working at the same location) aiming to produce code of a high quality I really believe this approach can work.

If anyone has experience with this, or similar approaches, I would love to hear your thoughts.

* Missing header file: HsUnixCompat.h

On my Debian system (Debian 5.0.3 – “Lenny”) the missing package was libbsd-dev:

$ cabal unpack unix-compat
Unpacking unix-compat-0.1.2.1…
$ cd unix-compat-0.1.2.1/
$ runhaskell Setup.lhs configure -v3
[…]
/usr/bin/gcc returned ExitFailure 1 with error message:
In file included from include/HsUnixCompat.h:1,
from /tmp/18515.c:1:
/usr/lib/ghc-6.10.4/unix-2.3.2.0/include/HsUnix.h:79:21: error: libutil.h: No such file or directory
$ apt-file search libutil.h
libbsd-dev: /usr/include/libutil.h

View from Råkvåg, Norway.

The sun over the Trondheim fjord a really cold day.