In the last couple weeks, we’ve explored a couple different Haskell open source projects. We checked out the Nix package manager and its Haskell cousin. Open source is very important to the Haskell community, so we’ll continue in this vein for a little while longer. This week, we’ll explore Codeworld, another project I learned about at Bayhac about a month ago. In the coming weeks, we’ll look at GHC itself, a vital open-source component of the Haskell ecosystem.
What is Codeworld?
Codeworld is an educational tool for teaching kids about mathematics and programming. The most basic version of Codeworld allows students to create geometric images. They do this using simple programming expressions similar to Haskell. Here’s a very basic program we can write and the picture it would draw.
leaves = sector(0, 180, 4) trunk = solidRectangle(1,4) tree = colored(leaves, translucent(green)) & colored(trunk, dark(brown)) program = drawingOf(tree)
This is different from similar sorts of programs and language in many ways. The Logo programming language that I first learned used a more procedural style. You create “turtles” that move around the screen and perform commands. For example, you could tell a turtle to start drawing, move 25 pixels, turn, and move again. You might also approach drawing in an object oriented fashion. You'd create shapes that have different properties and change these over time. But Codeworld eschews both these approaches in favor of a more functional style.
Your program is ultimately a single drawing. You can compose this drawing with different components, always represented by expressions. As you learn more about the different patterns, you can create your own functions.
leaves = sector(0, 180, 4) trunk = solidRectangle(1,4) tree :: (Color, Color) -> Picture tree(c1, c2) = colored(leaves, translucent(c1)) & colored(trunk, dark(c2)) myTree :: (Number, Color, Color) -> Picture myTree(x, c1, c2) = translated(tree(c1, c2), x, 0) program = drawingOf(myTree(-5, green, brown) & myTree(5, red, black))
Within a few examples, it’s relatively easy to teach the concept of recursion! Here’s a simple example showing repetition and fractals:
branch :: Number -> Picture branch(0) = blank branch(n) = polyline([(0,0), (0, 5)]) & translated(smallBranch, 0, 5) & translated(rotated(smallBranch, 30), 0, 2.5) & translated(rotated(smallBranch, -30), 0, 2.5) where smallBranch = scaled(branch(n-1), 0.5, 0.5) tree :: Picture tree = branch(7) program = drawingOf(tree)
Now the basic version of Codeworld is like Haskell but with some simplifications and syntactic changes. There is also Codeworld Haskell, which employs the full Haskell feature set. This lets you use more complex items and dive into the type signatures a bit more.
It also involves more complex functions than drawing. You can animations and interactions between different elements, or track a global state. It’s even possible to create simple games. The
interactionOf function allows you to handle input events that can affect the world. The
collaborationOf function looks a bit complicated with its use of
StaticPtr. But it allows you to create multiplayer games with relative ease!
drawingOf :: Picture -> IO () animationOf :: (Double -> Picture) -> IO () simulationOf :: world -> (Double -> world -> world) -> (world -> Picture) -> IO () interactionOf :: world -> (Double -> world -> world) -> (Event -> world -> world) -> (world -> Picture) -> IO () collaborationOf :: Int -> StaticPtr (Stdgen -> world) -> StaticPtr (Double -> world -> world) -> StaticPtr (Int -> Event -> world -> world) -> StaticPtr (Int -> world -> Picture) -> IO ()
The easiest way to get started is to go to https://code.world, follow the Guide, and make some simple programs! Everything takes place in your web browser, so you can get a feel for how it works without needing to do any setup.
If you want to contribute to or fiddle with the source code at all, you’ll have to do some more involved work. You’ll need to follow the instructions on the Github repository, which are primarily for the main Linux distributions. You’ll also need to sign a Google Contributor License Agreement if you haven’t already. But if you want to help on some kind of educational Haskell tool, this is a great project to contribute on! It’s already in use in several schools!
Next week we’ll continue our open-source focus by beginning to look at the process of contributing to GHC. This compiler is a mainstay of the Haskell community. And it depends entirely on volunteer contributions! Naturally though, it's difficult to understand all the inner workings of a compiler. So we’ll start at a very basic level and work our way up. We'll begin by looking at contributions to less technical areas. Only at the end of our discussion will we start looking at any of the organization of the code itself.
If you’ve never written any Haskell before, Codeworld is actually a great way to introduce yourself to some of the fundamentals! But for a more classical introduction, you can also get our Haskell Beginner’s Checklist. It’ll walk you through the basics of setting Haskell up on your system.