What options existed before I started Roy:

Why those options were suboptimal:

What I'm trying to achieve:

And what Roy currently is:

I got a lot of positive feedback which was motivating. I also heard some more news on using type inference in JavaScript engines for performance. It'd be great if we could figure out a way to use Roy's type information within those engines.

You can now see the type of assigned identifiers with the :t directive:

roy> let x = 100
roy> :t x
Number
roy> let a = [1, 2, 3]
roy> :t a
[Number]

A structure's values are printed instead of [object Object]:

roy> let x = {a: 1, b: true, c: "three"}
roy> x
{"a":1,"b":true,"c":"three"} : {a: Number, b: Boolean, c: String}

A helpful message is now shown when the lexer fails:

roy> can't lex this
Couldn't tokenise: 't lex this

And you can choose not to include the prelude when running files:

$ ./roy -p examples/option.roy 
{ _0: 6 }

Hopefully this will make the REPL experience a bit nicer.

In the "modules" branch, the website will have a few "document" definitions in the "dom" module. For example, there's a partial definition for "getElementById":

As you can see, passing a Number doesn't work because it expects a String.

I manually defined parts of the "document" object. The next step would be to use something like IDL to automatically generate the Roy module.

let obj = {x: 1, y: 2, t: "test"}
export obj

Will compile into this (in browser mode):

var _obj;
(function() {
var obj = {
"x": 1,
"y": 2,
"t": "test"
};
_obj = obj;
})();

It currently prefixes the global variables with an underscore. This was just for the initial version and I hope to get rid of it soon.

During my off-time, I worked on Roy's modules branch and made it capable of importing and exporting node.js modules. The branch adds an "export" macro:

let obj = {x: 1, y: 2, t: "test"}
export obj

This will assign the identifier to the "exports" global specified by CommonJS Modules/1.0:

var obj = {
    "x": 1,
    "y": 2,
    "t": "test"
};
exports["obj"] = obj;

My work on separate compilation causes a ".roym" file to be written during compilation:

obj: {x: Number, y: Number, t: String}

On the other side, there's an "import" macro:

import "./structural"

let f o = o.x + o.y
f structural.obj

Which loads the ".roym" file and assigns the types under the module name and compiles to node.js compatible requires:

var structural = require("./structural");
var f = function(o) {
    return o.x + o.y;
}
f(structural.obj)

That's it. Type-safe node.js modules. Awesome.

I have a few things to continue with:

• Add flags to change macros to target browser globals and AMD modules
• Fix writing all top-level type information to the ".roym" file; only write exported values

I'm going to write about functions in the next chapter.

David Pollak (@dpp) is working on a new programming language, he imagines it as a cross between Haskell and Excel. He asked:

Should code fail to compile if tests/contract and documentation are missing for public functions/structures/methods?

Paul Snively (@psnively) mentioned that types are all of the above:

@dpp Of course it should fail to compile if your types are wrong. ;-)

James Iry (@jamesiry) said maybe compile-time type errors could instead become warnings and emit runtime errors:

@psnively It's sometimes useful for an IDE to "warn" on type errors and generate exception code in place of the type problem.

The Eclipse JDT compiler is one that does this. I'm not sure why the Eclipse IDE needed this functionality but it seems like the Play framework uses it to present nice-looking compilation errors on page refresh:

The compiler works by noticing type errors (amongst others) like this:

int foo(String x) {
    return x * 2;
}

But continues by emitting code like this:

int foo(String x) {
    throw new TypeError("Expected an int but got a String at line 42 of Bar.java.");
}

Play comes along, catches that runtime exception and turns it into a pretty screen.

Haskell

Interestingly, this is exactly what Simon Peyton-Jones talked to me about during a YOW! Night here in Sydney. His idea is that people want to be able to run programs, even when the compiler is telling them that parts are wrong. He wants to add a mode to the Glasgow Haskell Compiler so code like this:

foo :: String -> Int
foo x = x * 2

Is transformed into:

foo :: String -> Int
foo x = error "Expected an Int but got a String at line 2 of Foo.hs"

And the Haskell compiler will print a warning during compilation:

WARNING: Foo.hs:2:8:
    Couldn't match expected type `Int' against inferred type `String'
    In the expression: x * 2
In the definition of `foo': foo x = x * 2

The following program would execute fine with no command-line arguments but otherwise show the type error at runtime:

import System (getArgs)

main = do
  args <- getArgs
  print $ if length args > 0 then foo [1, 2, 3] else 100

This might be useful for incomplete refactoring during development. You can modify part of your program and still run that part's tests while the types in other parts have become inconsistent.

Manuel Simoni (@msimoni) says it's also beneficial to go into inconsistency while redefining parts of your program, interactively:

Without the ability to be inconsistent, you can't support the Lisp Experience™

In any case, you'd definitely want to turn on treating type warnings as errors in production code.

Questions

Do you think this is a good option for statically-typed languages?

Simon seems to think this could attract fans of dynamic languages to Haskell. Would this sole feature satisfy them?

Temporary inconsistencies also play a part in distributed systems, could a similar idea be used?

The introduction covers why JavaScript isn't enough, the options that we have for not using JavaScript and the path that Roy takes. The next chapter will be on compile-time type-checking, one of the things that makes Roy unique for an altJS language.

I've also written a shell script that will run it through Pandoc to give you nice-looking HTML output, using Kevin Burke's Markdown.css:

The above was generated using the following Markdown:

% Roy - Babylonian Square Root

This is a Markdown file. It's also literate Roy code!

We're going to define a `sqrt` function using the
[Babylonian method][] for approximation.

    let sqrt n =

Making a good initial guess helps reduce the amount of
iterations until convergence. One method is to find the
highest-bit (`b`) and use `2^(b/2)`.

      let highestBit n i =
        if (1 << i) > n then
          i
        else
          highestBit n (i + 1)

      let guess = 1 << ((highestBit n 1) / 2)

Iteratively average the guess and the number divided by the guess
until convergence with a cut-off of 0.001. The guessing is started
from the initial value, calculated above.

      let nextGuess g =
        if (Math.abs (g - (n / g))) < 0.001 then
          g
        else
          nextGuess ((g + (n / g)) / 2)

      nextGuess guess

Now we can calculate the square root of 314 and print it.

    console.log (sqrt 314)

We should get an answer of around 17.720.

[Babylonian method]: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method

Happy New Year!

The file will be compiled and can be executed:

I decided to steal this while watching a Dart presentation at SydJS. The presenter mentioned the general idea and I later found out it was called Dart Tip. Rome tries to do exactly what Dart Tip does for Dart. Thanks for the idea, Dart team!

Merry Christmas!

This week I started work on separate compilation Roy. With the latest changes, a .roym file is generated on compilation that defines all top level types, like so:

even: Function(Number,Boolean)
odd: Function(Number,Boolean)
succ: Function(Number,Number)
pred: Function(Number,Number)

Currently the compiler only reads lib/prelude.roym for type information. I'm going to add a flag to specify where to read modules from.

This should be a start to a few issues:

• Add a way to give types to JS globals
• IDL binding generator

roy> let x= \a->   a+ 100
roy> :s x
\a -> a + 100

Notice that it pads out the operators. It also works on things like arrays and objects:

roy> let y = [1,2,3]
roy> :s y
[1, 2, 3]
roy> let z = {a: 1   , b:true, c:   "three"}
roy> :s z
{a: 1, b: true, c: "three"}

I have futures plans to expand this into a standalone formatter so that Roy source will have something like gofmt.

In other Roy news:

• We have some better monad examples
• I fixed a bug in recursive functions using data constructors
• The Roy version that the site is based off has been added to the footer of http://roy.brianmckenna.org/

data List a = Cons a (List a) | Nil

My one goal for this week was to make that possible. I managed to succeed and you can now even write fancier things like this:

data Tree a = TEmpty | TBranch a (Tree a) (Tree a)

console.log (TBranch 100 TEmpty (TBranch 100 TEmpty TEmpty))

// Won't compile:
// console.log (TBranch 100 TEmpty (TBranch "ASDF" TEmpty TEmpty))

I also fixed some simple problems with multiple declarations of things.

A very cool contribution has been a Roy TextMate/Sublime bundle:

Other awesome contributions have been:

• Unicode operators
• REPL improvements
• New bind and lambda syntax
• New example

This is after I created a GitHub mirror where Paul Miller filled out the issue tracker. I'm trying to work through the biggest bugs and then move onto extra features. Currently the biggest issue is the lack of recursive data types. That issue is blocking being able to write things like the cons list:

data List a = Cons a (List a) | Nil

(Which is also valid Haskell syntax)

This was actually part of a much bigger problem. Data constructors could only have generic parameters and not solid types specified in value constructors. For example, this wouldn't work:

data OptionN = SomeN Number | NoneN

And that was also a problem with type aliases:

type OptionS = Option String

Both problems have now been fixed. Now I'm pretty close to fixing the original recursive data type issue.

In other news:

• Roy now uses Git (clone this new repo if you have an old Mercurial version)
• Roy is now in DocPad!
• Roy is now in npm
• I fixed do notation not being typed correctly

It's been awesome to see such positive feedback. Thanks everyone.

1. CoffeeScript
2. ClojureScript
3. Dart
4. Roy

I say "focused" but the only thing I said about Dart was that I don't like it and I don't see anything good about it. The next SydJS is going to have someone from Google talking about Dart. Interesting.

A few questions were asked. One was to clarify source maps. I don't think I did a good job explaining them. They're a way to map from compiled JavaScript to original source files for debugging. The MozillaWiki has much more detailed info.

Another question was if there were any domain-specific languages. Kind-of. There are languages that are ports of others, languages that target callback hell and languages that target security. I don't know of any with limited business domains.

Ben Lupton later on asked me whether Roy was in npm (so he could add it to DocPad). Answer was "no" but now it's in both npm and DocPad!

I've posted the presentation slides online. Sadly, they will only work in WebKit browsers (e.g. Chrome, Safari and Epiphany).

• Make text huge
• Words as shapes

I wanted to experiment with the layout of my slides and focus completely on those. I tried doing it with Keynote and OpenOffice but they weren't making it very easy to create the style I wanted.

I thought doing it in HTML5 and JavaScript would be much easier. There is an awesome library called BigText, it resizes the CSS font-sizeuntil text fits to the container width - perfect for what I wanted.

I've been working on the SydJS slides for a while but tonight I extracted the skeleton and wrote a quick demo:

I've uploaded the demo online. If you want to create your own presentation, clone the skeleton from Bitbucket.

After I heard the news, I wondered how hard would it be to create a tiny Lisp in Scala. I imagined that Scala's parser combinators would make it very simple.

And then I remembered a project called Jitescript. Jitescript is a DSL inspired by Ruby's BiteScript. Both are very simple ways to output JVM bytecode.

So, I set out to write a Lisp to JVM bytecode compiler. I managed to fit it into 63 lines of code. Sure, it's not going to compete with Clojure any time soon but I think it shows how easy it is to write a JVM language. I think we could make it even nicer by adding some Scala magic to Jitescript.

You put the S-expression as an argument to the SBT REPL:

> run (- (- (+ (- (+ 99 11) 10) 11) 10) 10)

And then run the Lisp.class:

$ java Lisp
91

(Works out to the number 91)

Here are the 63 lines of Scala:

package scalispa

import util.parsing.combinator.RegexParsers

import java.io.{ File, FileOutputStream, PrintStream }

import me.qmx.jitescript.{ JiteClass, CodeBlock }
import me.qmx.jitescript.util.CodegenUtils.{ p, ci, sig }

import org.objectweb.asm.Opcodes._

sealed trait Node
case class SExp(l: List[Node]) extends Node
case class SInt(i: Int) extends Node
case class SIdent(s: String) extends Node

object Parser extends RegexParsers {
  def int = regex("""[0-9]+""".r) ^^ { (i: String) => SInt(i.toInt) }
  def ident = regex("""[A-Za-z+-/\*]+""".r) ^^ SIdent
  def sexp = "(" ~> rep(node) <~ ")" ^^ SExp
  def node: Parser[Node] = int | ident | sexp
  def apply(s: String) = parse(sexp, s)
}

object Evaluator {
  def compile(b: CodeBlock, n: Node) {
    n match {
      case SExp(Nil) => {}
      case SExp(x :: xs) => {
        xs.foreach(compile(b, _))
        compile(b, x)
      }
      case SInt(x) => b.pushInt(x)
      case SIdent("+") => b.iadd()
      case SIdent("-") => b.isub()
      case SIdent("*") => b.imul()
      case SIdent("/") => b.idiv()
    }
  }

  def apply(program: SExp) {
    val b = new CodeBlock
    compile(b, program)
    b.iprintln().voidreturn()

    val name = "Lisp"
    val c = new JiteClass(name)
    c.defineMethod("main", ACC_PUBLIC | ACC_STATIC, sig(classOf[Unit], classOf[Array[String]]), b)

    val stream = new FileOutputStream(new File(name + ".class"))
    stream.write(c.toBytes)
    stream.close()
  }
}

object Main {
  def main(args: Array[String]) {
    Parser(args mkString " ") match {
      case Parser.Success(p, _) => Evaluator(p)
      case a => println(a)
    }
  }
}

The code is up on Bitbucket, under the unimaginative repo name of Scalispa. Let me know what you think!

Friday night at 6pm we heard around 20 pitches, voted and then heard more from the top 8. We voted again and split up into 4 teams:

• Social pet sitting
• Social trips
• Social gifts
• Social volunteer network

Notice a social trend?

I chose to be part of the group working on the volunteer network. The idea was to create something a little bit like StackOverflow but instead of questions/answers we have charities/volunteers.

Charities add their initiatives. Volunteers browse initiatives, choose to participate and receive points that are shown on their profile. The idea is to help get people hooked into contributing to charities.

Our group of 9 built an initial version, put it up on Ninefold and made available at HappyTri.be. The main technology used was Python, Django and Pinax.

Launch48 was a great way for me to get involved in a startup. I had fun, created something interesting, learned some new skills and uncovered something that I think is a big opportunity. I definitely recommend it.

type Name = String
type Animal = {name: Name, legs: Number}
let zebra: Animal = {name: "Zebra", legs: 4}

The benefits are mainly for structural types:

1. You don't have to type out a long structure whenever you want to be explicit
2. Better error messages

For example, this is a poorly typed program without an alias:

let getName x = x.firstName ++ x.lastName
console.log (getName {})

And this is the error message:

Type error: {} is not {firstName: String, lastName: String}

You can imagine the error would be kind of scary if the structure was heavily nested or had more than just a couple of elements.

This is a poorly typed program with an alias:

type Person = {firstName: String, lastName: String}
let getName (x: Person) = x.firstName ++ x.lastName
console.log (getName {})

And this is the nicer error message:

Type error: {} is not Person

I originally wanted inference to use the scope to check which aliases it could satisfy and use the most appropriate:

type Person = {firstName: String, lastName: String}
// `x` is inferred to be Person from the scope
let getName x = x.firstName ++ x.lastName

Which is something that Yeti is able to do. Instead, I implemented a very simple version that will just propogate explicit aliases. Using the simple version might conflict with my future plans.

Later on I hope to be able to use the type aliases to output nicer JavaScript:

 // Roy: type Person = {firstName: String, lastName: String}
 var Person = function(firstName, lastName) {
     this.firstName = firstName;
     this.lastName = lastName;
 };

And I might even be able to extend aliases to output information about the hierarchy:

// Hypothetical Roy: type Employee = Person with {wage: Number}
var Employee = function(firstName, lastName, wage) {
    Person.call(this, firstName, lastName);
    this.wage = wage;
};
// Just for documentation:
Employee.prototype = new Person();

But maybe not. I'll have to try it out.

In adding aliases, I fixed something that I wanted to do for a while; using structural types for normal type annotations:

let getName (x: {name: String}) = x.name
console.log (getName {name: "TEST"})

Let me know what you think.

data Tuple a b = Tuple2 a b

I could add some syntactic sugar on top to completely hide the data type.

The second way would be to use a structure, something like this:

type Tuple2 a b = {0: a, 1: b}

(The above isn't valid Roy code, I don't have type aliases in yet)

I could also add sugar to hide this method. Pretty similar to what ML does.

Because of JavaScript's property access, I can actually compile tuples to JavaScript arrays very easily. That means this:

let x = (1, true, "three")

Can compile to this:

var x = [1, true, "three"];

And still compile down as if it was a structure with numeric keys:

x[0] == 1
x[1] == true
x[2] == "three"

An interesting part of the structural approach is that higher-arity tuples are subtypes of lesser-arity tuples. For example (1, 2, 3) is a subtype of (4, 5). I'm not sure if this is good or bad thing but ML seems to get away with it.

I'm currently running with the structural way of implementing tuples. I think that having two different possibilities shows a problem with Roy - it doesn't make sense to have two ways of constructing product types. I should just go the ML way and have ADT options only take up to a single parameter.

let xor e = match e
  case (Left (Left n)) = 0
  case (Left (Right n)) = n
  case (Right (Left n)) = n
  case (Right (Right n)) = 0

console.log (xor (Left (Left 100)))
console.log (xor (Left (Right 100)))
console.log (xor (Right (Left 100)))
console.log (xor (Right (Right 100)))

Which wil output:

0
100
100
0

Here's some code I wrote while trying to break it:

let x a = match a
  case (Some (Some (Some s))) = s
  case (Some (Some None)) = 0
  case (Some None) = 0
  case None = 0

// Doesn't compile:
// console.log (x (Some (Some (Some None))))

console.log (x (Some (Some (Some 42))))
console.log (x (Some (Some None)))
console.log (x (Some None))
console.log (x None)


data Tuple a b c = Tuple2 a b | Tuple3 a b c

let addTuple t = match t
  case (Tuple3 a (Tuple3 b c d) e) = b + c + d
  case (Tuple3 a (Tuple2 b c) d) = b + c
  case (Tuple2 a (Tuple3 b c d)) = b + c + d
  case (Tuple2 a (Tuple2 b c) d) = b + c

console.log (addTuple (Tuple3 "addTuple" (Tuple2 1 2) "addTuple"))
console.log (addTuple (Tuple3 "addTuple" (Tuple3 1 2 3) "adsf"))
console.log (addTuple (Tuple2 "addTuple" (Tuple2 1 2)))
console.log (addTuple (Tuple2 "addTuple" (Tuple3 1 2 3)))

Both functions broke the type checking but now work.

I've been working on just deep matching for the past week. I really need to start proving parts of Roy's type system instead of just writing it in JavaScript and hoping it works (and makes sense).

The with keyword

Roy is built on the idea of structural typing. Up until now Roy didn't have a nice way of extending structures - users had to do this:

let addWorldField o = {hello: o.hello, world: false}

// type is: Function({hello: Boolean},{hello: Boolean, world: Boolean})

console.log (addWorldField {hello: true})

Pretty ugly. My solution was steal the with keyword from Yeti:

console.log (addWorldField {hello: true} with {world: false})

Bug fixes

Along with implementing the with keyword, I fixed some more bugs.

A huge one that had been annoying me for a long time, was a problem with type-checking tags:

// Fixed bug with unification over tags
console.log (Some 1)
console.log (Some "Test")

When using the REPL or running .roy files with the '-r' flag, the standard library wasn't imported.

Future

Coming up next in Roy:

• Mutable references
• Deep pattern matching

Hopefully I'll have even more to show next week!

The above video is made up of about 20 hours worth of screenshots, compressed down to 2 minutes.

I cleaned up the scripts I wrote and pushed them to Bitbucket. Works on both Linux and Mac OS X.

The theme was "Mutate!" - we got together and came up with the concept of a tower defence game that used a genetic algorithm to evolve.

We named the game "Smooth Jazz Tower Defence". Here are the instructions form the README:

This is a tower defence game with a twist: creeps mutate! The game uses a genetic algorithm to select the best creeps and breed them together. A little bit of mutation is thrown in for a bit of spice, just like in evolution.

For both creeps and turrets, colours signify the specialties:

• Red: health
• Blue: armour
• Green: speed

A good first strategy is to place one of each turret at the start of the map.

To place a turret, click its icon from the right side of the screen. Hover your cursor over a bright red square and click.

Sit back, relax and let the smooth jazz sooth your soul.

I've uploaded a video of the game to YouTube:

The game runs on Windows, Mac, Linux and anything else that supports Pyglet. Download links are on our PyWeek page.

I started by looking around for an open-source, command-line Java decompiler. Almost all had no activity since 2004-2008. JReversePro was last touched in January, 2010 so seemed like a good candidate to pick up and continue.

I updated the run scripts, made changes to the spacing, started work on JSR-14 (Adding Generics to the Java Programming Language) and wrote an Emacs script for automatically decompiling .class files.

If you want to try it out, build JReversePro:

git clone https://github.com/pufuwozu/jreversepro.git
cd jreversepro
mvn package

In Emacs, use M-x load-file to load the jrevpro.el file under the scripts directory. Use M-x set-variable jrevpro-script to change the location to the jrevpro script under the same directory. You should now be able to open a .class file and have it automatically decompiled to Java.

You write some JavaScript and it is executed whenever Cloud9 is loaded. My idea behind this was to be able to extend the editor without changing anything server-side.

See the README for installation instructions. Once installed, a button will appear on the right dock:

Clicking it will present a code editor. This is where you type in your user script. When you're ready, press Control+Shift+E to evaluate and save the script.

Clone the repository and try it out!

Walk cycle in low resolution pixel art

Time is always limited during PyWeek. To make a nice looking game, you have to be able to rapidly create art. I've been working on minimising the amount of pixels used. I think this has two direct benefits:

• Low resolution graphics look nice
• They are very quick and fairly easy to create

Ideally I want less than 8x8 pixel characters but I've found that it's hard to create a nice looking walk animation with limited pixels. My first take was to create characters with 1px high legs:

It's not very obvious that the character is walking. I thought that some shading might improve the situation:

Only a little. Next thought was that the legs just don't have enough definition. Adding a knee helped a bit:

Adding some shading to the legs helped even more:

But I wanted something more fluent. I wasn't sure how to create it with the platformer side/front on view like above but I had an idea of how I wanted it to look side on:

Looks nice! I took the animations of each leg and added it back to the platformer angle:

The legs look like a mess half-way into the animation. I thought it might be caused by the legs being too close together. I moved them apart by a pixel:

It actually looks pretty good! But then I thought, is it really much of an improvement to one of the simpler ones?

In the end, I'm not sure if it's worth the extra work when you're under heavy time constraints.

Reloading Python modules

This PyWeek I want to try to write the game in a style that will allow for reloading of parts while it's running. It turns out that Python has a reload built-in that's makes this really simple!

I made a small proof of concept. I created a file called "constants.py" that included a single constant:

SPEED = 10

I then wrote some game code. Pressing the right key will move the player to the right by SPEED pixels. Pressing 'r' will reload the constants.py file. Using Pyglet:

#!/usr/bin/env python
import pyglet
import constants

window = pyglet.window.Window()

animation = pyglet.image.load_animation('Cycle7.gif')
sprite = pyglet.sprite.Sprite(animation)

@window.event
def on_draw():
    window.clear()
    sprite.draw()

@window.event
def on_key_press(symbol, modifiers):
    if symbol == pyglet.window.key.RIGHT:
        sprite.x += constants.SPEED
    elif symbol == pyglet.window.key.R:
        reload(constants)

pyglet.app.run()

So while running, I can modify constants.py:

SPEED = 100

Then switch back to the game, press 'r' and then press the right button to move the character by 100 pixels! Hopefully this will let us rapidly play with game values without having to exit and restart the game.

One of the first exercises in Chapter 3 (The Use of Logic: Proof) is 3.4:

• Assume that n and m belong to the set of natural numbers
• Show that: if m is odd and n is odd then m + n is even

My proof involved:

• n-1 is even
• m-1 is even
• 2 is even
• Thus n-1 + m-1 + 2 = n + m is even

I decided to try Agda on this proof. First I needed to define a data type for even and odd numbers. I eventually came up with a mutually recursive definition:

mutual
  data Even : Set where
    zeroE : Even
    succE : Odd -> Even
  data Odd : Set where
    succO : Even -> Odd

The base case is even zero. Every number after is built like so:

succE (succO (succE (succO zeroE)))

This example represents 4 and belongs to the even set.

The above problem has this type signature:

_odd+_ : Odd -> Odd -> Even

That is, an odd plus an odd always equals an even.

The first two cases for this function are easy. If either side is one (succO zeroE), then we just increment the other side, which makes it even:

succO zeroE     odd+ n               = succE n
n               odd+ succO zeroE     = succE n

The last case is a bit confusing. We take 2 off each side to get to the previous odd number, recurse and then add back on the 4 that we subtracted:

succO (succE n) odd+ succO (succE m) = succE (succO (succE (succO (n odd+ m))))

I started writing the proof in Agda but didn't end up using any dependent types - a unique feature to languages like Agda. My solution could have easily been made by using another language. For example, here is a direct Haskell translation:

data Even = ZeroE | SuccE Odd
data Odd  = SuccO Even

oddPlus :: Odd -> Odd -> Even
oddPlus (SuccO ZeroE) n = SuccE n
oddPlus n (SuccO ZeroE) = SuccE n
oddPlus (SuccO (SuccE n)) (SuccO (SuccE m)) = SuccE $ SuccO $ SuccE $ SuccO $ oddPlus n m

Maybe I'm not familiar enough with dependent types to use them in my solution. I imagine that a larger chunk of the problem could have been encoded into the type system. Hopefully I'll figure out some tricks as I work through the book.

Some restrictions:

• Only HTML5; no plugins
• Related to the location of the Developer Day
• Licensed under the Creative Commons Attribution 3.0 Unported License

I came up with the idea of using WebGL to transform the logo into the Sydney Opera House. This is what I made:

Implementation

I first looked at three.js to see what options there were for using 3D data and animating it. I found that morph animation was added to three.js as part of the RO.ME project. Perfect!

I imported the SVG logo into Blender. I had some troubles at first but it imported nicely after deleting the text from the vector. The next problem was that each edge had many unnecessary vertices.

I tried extruding the mesh but the polycount increased to about 5,000 - not very acceptable for morphing. I minimised the original polycount largely by using the Decimate modifier. Decimate would close up a few of the small holes so I decreased the polycount there by manually merging vertices. I eventually got the extruded polycount down to about 300.

For animation, I added a photo of the Opera House as a background for reference. I used shape keys to transform the triangles to corresponding positions/sizes.

To export, I just had to step through the timeline and export each frame separately. This created 10 obj files that I could use with the three.js conversion script:

python convert_obj_three.py -i frame_00.obj -o Visual.js -m "frame*.obj"

The model could then be used with three.js:

var loader = new THREE.JSONLoader(true);
loader.load({
  model: "Visual.js",
  callback: function(geometry) {
    // Create material and add to scene
  }
});

I wanted animation to be achieved through "scrubbing" the mouse across the X axis. That was pretty easy to implement using three.js morph targets:

var currentFrame = Math.floor(ratio * framesCount);
var transitionAmount = (ratio * framesCount) % 1;

mesh.morphTargetInfluences[currentFrame] = 1 - transitionAmount;
mesh.morphTargetInfluences[currentFrame + 1] = transitionAmount;

To finish it off, I added some animated three.js particles, a CSS3 gradient for the background and some simple visual cues. I've put my entry live and pushed the code to Bitbucket.

December of last year I started work on a Parrot Assembly Language (PASM) to JavaScript compiler called Ringneck. Last week I found it again and now I'm releasing it. The idea was that if many languages compile to PASM, I could get many languages to compile to the web just by compiling PASM to JavaScript.

Ringneck takes PASM like this:

  set     I1, 1
  if      I1, TRUE
  print   "False!\n"

  branch  END
TRUE:
  print   "True!\n"
END:
  end

And compiles to something like this:

var label;
while(true) {
switch(label) {
default:
    opcodes.core.set.apply(null, [{"type":1,"text":"I1","reg":"I","index":1},{"type":2,"text":"1","value":1}]);
    if(regs["I"][1].value != 0) {label = "TRUE"; break;}
    opcodes.io.print.apply(null, [{"type":4,"text":"\"False!\\n\"","value":"False!\n"}]);
    label = "END"; break;
case "TRUE":
    opcodes.io.print.apply(null, [{"type":4,"text":"\"True!\\n\"","value":"True!\n"}]);
case "END":
    flush(); return;
}
}

I've put a demo up. Feel free to clone the Bitbucket repo.

I'm an avid Emacs user because Emacs is extremely extensible; I'm able to write some Lisp to make Emacs work exactly as I like. I wanted the same concept to be core to my toy editor, you write some JavaScript and extend the editor at runtime.

I didn't get very far because I was constantly running into problems with DOM Ranges. What I did achieve was syntax highlighting (via parse-js.js in UglifyJS) and JavaScript evaluation:

I've put a demo up and the code is on Bitbucket. Only tested in Chrome. Editing is very limited and will only work on a single line. Evaluate your JavaScript with CTRL/CMD+J.

I like the fact that JavaScript is highly event based but code can easily become callback hell. Take this for example:

app.get('/index', function(req, res, next) {
    User.get(req.params.userId, function(err, user) {
        if(err) next(err);
        db.find({user: user.name}, function(err, cursor) {
            if(err) next(err);
            cursor.toArray(function(err, items) {
                if(err) next(err);
                res.send(items);
            });
        });
    });
});

Yuck! Let's try to fix this with a simpler example. Here are the goals:

• Write a sequence of function calls
• Have each call be wrapped with an asynchronous timeout callback

In the end, I want to be able to write code like this:

(timeout/timeout-macro
   (pn "Hello")
   (pn "World")
   (p "Hello")
   (p " ")
   (p "world")
   (p "!")
   (p "!")
   (pn "!")
   (pn (+ 1 2 3))
   (pn "Done"))

Lisps are great at solving this problem because they are homoiconic. They can have powerful macro systems because code can be transformed exactly the same as data. Here is the macro I wrote for this problem:

(defmacro timeout-macro [& body]
  (reduce
   (fn [x y]
     `(timer/callOnce (fn [] ~x ~y) 1000))
   `(fn [])
   (reverse body)))

With the macro, ClojureScript transforms the function calls above into some awesomely ugly JavaScript:

callOnce.call(null, (function () {
  callOnce.call(null, (function () {
    callOnce.call(null, (function () {
      callOnce.call(null, (function () {
        callOnce.call(null, (function () {
          callOnce.call(null, (function () {
            callOnce.call(null, (function () {
              callOnce.call(null, (function () {
                callOnce.call(null, (function () {
                  callOnce.call(null, (function () {
                    return pn.call(null, "Done");
                  }), 1000);
                  return pn.call(null, cljs.core._PLUS_.call(null, 1, 2, 3));
                }), 1000);
                return pn.call(null, "!");
              }), 1000);
              return p.call(null, "!");
            }), 1000);
            return p.call(null, "!");
          }), 1000);
          return p.call(null, "world");
        }), 1000);
        return p.call(null, " ");
      }), 1000);
      return p.call(null, "Hello");
    }), 1000);
    return pn.call(null, "World");
  }), 1000);
  return pn.call(null, "Hello");
}), 1000);

This is known as an automatic continuation-passing style (CPS) transform. I've put the demo up here and posted the code up on Bitbucket.

I'm going to work on cleaning it up but the test runner currently stands at 24 lines of Roy code:

let fs = require 'fs'
let path = require 'path'
let child_process = require 'child_process'

let dir = "test"
let files = fs.readdirSync dir

let tests = files.filter (fn x =
  (x.lastIndexOf '.roy') == (x.length - 4)
)

tests.forEach (fn t =
  let name = path.join dir t
  let outFile = (path.join dir (path.basename t '.roy')) ++ '.out'
  child_process.exec './roy -r ' ++ name (fn error stdout stderr =
    if error then
      console.log "Error:" error.message
    else
      let expected = fs.readFileSync outFile 'utf8'
      let actual = stdout.toString ()
      console.assert actual == expected "Output of " ++ t ++ ": " ++ (JSON.stringify actual) ++ " does not match " ++ (JSON.stringify expected)
      console.log "Pass:" name
  )
)

Not too ugly. It seems like some standard library functions could make it nicer.

I remember reading a while ago about someone using JHC to compile a Haskell executable for the iPhone. JHC is a Haskell compiler that outputs fairly sane C code. I figured that it'd be fairly easy to get it to output code to work with devkitPro.

I had a quick version of this project working in December but I lost the patches and wanted to make a better version.

After a days work I had something compiling and I spent another day playing around with it. I think I created the world's most annoying Haskell program:

It is much more annoying running on a physical DS:

I've uploaded the binary for people to try out. I've put the example project up on Bitbucket. The main Haskell for the example is:

printFreq freq = do
  consoleClear
  print freq

setSound sound freq = do
  soundSetFreq sound freq
  printFreq freq

keyLoop sound = do
  x <- keyboardUpdate
  scanKeys
  if x > 0 then do
    setSound sound $ x * 100
    putChar $ chr x
  else if isTouching then do
    if getTouchY < 110 then do
      setSound sound $ getTouchY * 100
      print getTouchY
    else
      return ()
    r <- randomRIO (0, 31)
    oamMainColor r 0 0
    oamMainSet getTouchX getTouchY
  else
    return ()

  swiWaitForVBlank
  oamMainUpdate
  keyLoop sound

main = do
  consoleDemoInit
  keyboardDemoInit
  keyboardShow
  soundEnable
  sound <- soundPlayPSG dutyCycle_50 10000 127 64
  oamMainInit
  keyLoop sound

To compile you have to setup devkitARM with my patch to libnds. You then need to setup JHC with my DARCS patch. I've forwarded the patches on so hopefully it will just work in the future!

Before this project, it was possible to run Hugs on the DS. While I think that is really awesome, I took the JHC approach for a few reasons:

1. I couldn't figure out an easy way to access C libraries from Hugs.
2. I wasn't sure how to make Hugs jump straight to executing custom Haskell code.
3. Hugs is interpreted. I had a feeling that compiling to C and using GCC would give better performance.

Although the above example code is fairly ugly, I'm very confident that a nice DSL could be created for writing games. I'd love to see this happen.

macro printArgLength =
  console.log "Compiling to:" arguments.length
  [| console.log &(arguments.length) |]

printArgLength 1
printArgLength 1 2
printArgLength 1 2 3

The code above will output messages during compilation. This is the JavaScript output:

console.log(1)
console.log(2)
console.log(3)

I'd really like to make Roy's meta-programming work more like Template Haskell or Converge. Unfortunately I have only skimmed papers on both and used neither. My goal is to make the meta-programming powerful enough to express modules and do notation.

I also built a REPL for Roy in about 20 minutes. Amazing how simple it is to create a nice REPL in node.js by using the readline module.

$ ./roy
roy> 10 * 2 - 5
15 : Number
roy> 

1. JavaScript itself doesn't support modules
2. Roy needs static type information to be useful

To illustrate the problem, in CommonJS we do this:

var x = require('./x');
exports.a = x.y;
exports.b = 1;

In the browser we do this:

window.m = {a: window.x.y, b: 1};

How do we create a solution that imports/exports type information across both?

I don't think it's possible. I might have to resort to making the Roy compiler modal (CommonJS or bowser modes).

That problem aside. I did commit something this week - the start of a standard library:

console.log (id 1) // 1
console.log (odd 2) // false

console.log (maybe 0 id None) // 0

console.log (head (tail (replicate 10 'a'))) // a

While writing the standard library I've found a lot of holes in the type system. I'll try to fix them for next week!

data Option a =
  Some a | None

let optionMonad = {
  return: fn x =
    Some x
  bind: fn x f = match x
    case (Some a) = f a
    case None = None
}

console.log (do optionMonad
  bind x = Some 1
  let y = 2
  bind z = Some 3
  return x + y + z
)

Note the do optionMonad. Explicitness is only necessary because Roy doesn't have any form of interfaces or type classes. An upside is that a single datatype could have multiple monad implementations, something not allowed in most other languages.

I also worked on prettying up the JS output. It now looks like this:

"use strict";
var Some = function(a){this._0 = a};
var None = function(){};
var optionMonad = {
    "return": function(x) {
        return new Some(x);
    },
    "bind": function(x, f) {
        return (function() {
            if(x instanceof Some) {
                var a = x._0;
                return f(a)
            } else if(x instanceof None) {
                return new None()
            }
        })();
    }
};
console.log((function(){
    var __monad__ = optionMonad;
    return __monad__["bind"](new Some(1), function(x) {
        var y = 2;
        return __monad__["bind"](new Some(3), function(z) {
            return __monad__["return"](x + y + z);
        });
    });
})())

Structural typing is a really awesome type system feature. Here's an example:

let obj = {x: 1, y: 2, t: "test"}

let getX a = a.x + 2

console.log (getX obj)
console.log (obj.x + obj.y)

let plusXY a = a.x + a.y
console.log (plusXY obj)
console.log (plusXY {x: 2, y: 1})

let makeXY x y = {x: x, y: y}
console.log (plusXY (makeXY 1 2))
console.log (makeXY 1 2)

// Won't compile
// plusXY {x: 1, z: 2}

console.log ((fn obj = obj.a.a + obj.a.b) {a: {a: 1, b: 2}})

let makeFun a = {f: fn b = a.x + b.y}
console.log ((makeFun {x: 1}).f {y: 2})

The idea is that an object is a subtype if it can satisfy all of another object's properties.

Visit Roy's website to give the language a try from your browser. I've only tested it in Chrome and Safari. It definitely won't work in IE.

data Maybe a =
  Some a | None

let printSomething m = match m
  case (Some x) = console.log x
  case None = console.log "Empty"

printSomething (Some 1)
printSomething None

data Either a b =
  Left a | Right b

let printString (s : String) =
  console.log s

let printResult e = match e
  case (Left x) = console.log x
  case (Right x) = printString x

printResult (Left 10)
printResult (Right "Error")

// Won't compile:
// printResult (Right 10)

data Bool =
  True | False

let getBool b ifTrue ifFalse = match b
  case True = ifTrue
  case False = ifFalse

console.log (getBool True 1 2)
console.log (getBool False 1 2)

Running the above example (with ./roy examples/data.roy && node examples/data.js) will print the following:

1
Empty
10
Error
1
2

The current version of pattern matching has no exhaustiveness check. I'll try to figure out how to do that later on.

It uses my past two projects from projectaweek:

• Type inference
• Whitespace lexer

Here's an example of the language:

let gcd a b =
  if b == 0 then
    a
  else
    gcd b (a % b)

console.log (gcd 49 35)

And here's the (ugly) JavaScript output:

"use strict";
var gcd = function(a, b) {return (function(){if(b == 0){return a}else{return gcd(b, a % b)}})();;};
console.log(gcd(49, 35))

Roy will serve as the basis for a new language I'm working on. The next language will:

• Improve JavaScript interop
• Structural typing
• Tail recursion
• Algebraic data types
• Pattern matching
• Prettify the JavaScript output

The code is up on Bitbucket. It analyses a small, ML-like language.

This week I am releasing my JavaScript implementation of Hindley-Milner type inference (a.k.a. Algorithm W).

The source is on Bitbucket and I've generated some literate-style code docs using Docco. Check them out here:

• typeinference.js
• types.js

A year and a half went by and I've come back to try Scala on Android. There's now a few resources on the topic, even one from ScalaIDE. I haven't been completely satisfied with the solutions I've read so I came up with the following.

Instructions

Install ScalaIDE in Eclipse and create a new Android project.

Make sure there is a directory called libs and copy in scala-library.jar. Make a new directory called tools and copy in scala-compiler.jar.

Generate an Ant build.xml file:

$ ~/android-sdk-linux_86/tools/android update project --target 1 --path .

Define a pre-compile stage in build.xml and add a Scala task:

<target name="-pre-compile" depends="-resource-src">
    <taskdef resource="scala/tools/ant/antlib.xml"
             classpath="tools/scala-compiler.jar:libs/scala-library.jar" />

    <scalac force="changed" deprecation="on" destdir="${out.classes.absolute.dir}"
            bootclasspathref="android.target.classpath">
        <src path="${source.absolute.dir}" />
        <src path="${gen.absolute.dir}" />
        <src refid="project.libraries.src" />
        <classpath>
            <fileset dir="${jar.libs.absolute.dir}" includes="*.jar" />
        </classpath>
    </scalac>
</target>

Android doesn't work very well when converting a huge amount of Java bytecode to Dalvik bytecode. To get around this, we can use Proguard to remove all unused parts of the Scala library. Enable Proguard for debug releases by adding the following to build.xml:

<target name="-debug-obfuscation-check">
    <property name="proguard.enabled" value="true" />
    <path id="out.dex.jar.input.ref" />
</target>

Make the install target local to our build.xml instead of importing it. This will make it easier for Eclipse later on:

<target name="install" depends="debug">
    <install-helper />
</target>

Add the following line to default.properties:

proguard.config=proguard.cfg

The Scala library will cause warnings and make Proguard stop. Make it continue by adding the following to proguard.cfg:

-dontwarn

Remove the default run configuration from Eclipse and add a new external run configuration. The buildfile should be ${project_loc}/build.xml and the base directory should be ${project_loc}. Go to the "Targets" tab and tick the "install" target.

Delete the default Java source file and recreate it using Scala:

package org.brianmckenna.helloandroid

import android.app.Activity
import android.os.Bundle

class HelloAndroid extends Activity {
  override def onCreate(savedInstanceState: Bundle): Unit = {
    super.onCreate(savedInstanceState)
    setContentView(List(R.layout.main) head)
  }
}

After starting the emulator and running Ant, Scala should now run on Android!

• par and pseq
• parList, parListChunk, parMap, r0, rwhnf and rnf
• Data Parallel Haskell
• Intel CnC
• forkIO with MVar, Chan, QSemN and STM

The presentation is online here:

http://brianmckenna.org/files/presentations/haskell-parallel/

On Bitbucket here:

https://bitbucket.org/puffnfresh/presentations

Downloadable as a zip here:

http://brianmckenna.org/files/presentations/haskell-parallel.zip

Illustration from LYAH by bonus500

I'm looking for something that:

• Is interesting
• Takes skill and effort
• Has some potential barriers
• Would be appreciated
• Is preferably open-source

Do you use any software could use a speed up? Do you have a project that could use some parallelisation?

A WebGL implementation for node.js!

Here's a screenshot of it next to WebGL in Chromium (even running the same JavaScript):

I've chucked it up on GitHub but if you're having a go, be aware that I've only implemented enough OpenGL calls to run my example. I'd really appreciate any help implementing the other functions.

This project is part of something much bigger. Imagine easily writing games or multimedia applications that run in the browser and on the desktop without changes. Stay tuned.

I work part-time as a web developer at a marketing and advertising agency which heavily uses WordPress as a CMS. Like many developers, we use local development machines to add new functionality and fix bugs, we then migrate those websites onto our client’s web servers. If you’re very familiar with WordPress you’ll probably know that migrating an install is fairly horrible. That’s what I plan to fix.

I’ll try to put an easy to use interface (hopefully with some help from the WordPress UI/UX team) that will let the user type in their new URL, new FTP credentials and new database server credentials. The blog will then be able to use all of those details and move itself over, automatically. I’m not a UI designer so please forgive my mock-up:

I’ll be posting a revised project proposal to this blog soon. It will be at the following URL when it’s ready:

http://gsoc2010.wordpress.com/brian-mckenna-automatic-migration/

This has been a brief overview of my project. What do you think of the idea? What would you like to see implemented?

I was the sole programmer on the team, there were two other people working on art and music. I was really happy with the end product (even though it was rushed). The reviews of our game are public, here are a few choice ones:

Anonymous:

Excellent concept. Hard and tricky game - had to think to get through this game (that's good) and it doesn't repeat "puzzles" much. Well executed, the jumping/bouncing feels nice and bouncy. Great graphics and nice music. Intro video was neat, although I think it could've taken the whole screen. Excellent work on this game, I just wish it was longer. You should really give some thought into making this a full game, with more levels, a tutorial, a better storyline and everything (maybe some new features would be nice too, like different types of jelly). I really think it has potential for a great "full game". :)

Anonymous:

I was extremely impressed by this entry! Great job! However, the learning curve level was way too hard for me to really enjoy it. If there were more tutorial parts and less mid-air precision shots, I would have had a lot of fun with it.

Anonymous:

Retro look. Platforming with jelly bouncing. What's not to like? Apart from the fact that I ran out of goo that is.

Anonymous:

I was amazed by the production values of this game. Really cool art style. The gameplay is nice... but i couldn't figure out how to cross beyond the first obstacle :(

I've posted some videos of the game to YouTube:

I have created a Windows package for anyone who wants to try it out. There is also a Python source version for people on other systems - the only problem is that the source version requires Pyglet.

I'm planning on working on this game a bit further and entering into the Pyggy Awards.

A lot of people misunderstand JavaScript, possibly because its syntax looks like most other programming languages (where Lisp/Haskell/OCaml behave and look completely different).

JavaScript is sometimes called object-oriented. It is a loosely-typed dynamic language and doesn't have classes nor classical inheritance. This means that when JavaScript is compared to Java or C++, the concepts just don't match up.

I find that JavaScript can be better compared to a Lisp; it has closures and first-class functions. Using them you can create other functional programming techniques, such as partial application (currying).

Today's aim is to make a piece of JavaScript act more functional. Let's take an example (using sys.puts from node.js):

var external;
function foo() {
    external = Math.random() * 1000;
}
foo();

sys.puts(external);

To get rid of global side effects, we can wrap it in a closure:

(function() {
    var external;
    function foo() {
        external = Math.random() * 1000;
    }
    foo();

    sys.puts(external);
})();

Notice that we can't actually do anything with external or foo outside of the scope. They're completely wrapped up in their own closure, untouchable.

Now, to get rid of the external side-effect:

(function() {
    function foo() {
        return Math.random() * 1000;
    }

    sys.puts(foo());
})();

That's as far as we'll get. In the end, the example is not purely-functional because it can't be. Using a random number reads from the global state (to get a seed) and printing to the console is a side-effect.

I also want to point out that mixing functional programming with objects is perfectly fine. Take this for example:

var Square = function(x, y, w, h) {
   this.x = x;
   this.y = y;
   this.w = w;
   this.h = h;
};

function getArea(square) {
    return square.w * square.h;
}

function sum(values) {
    var total = 0;

    values.forEach(function(value) {
        total += value;
    });

    return total;
}

sys.puts(sum([new Square(0, 0, 10, 10), new Square(5, 2, 30, 50), new Square(100, 40, 20, 19)].map(function(square) {
    return getArea(square);
})));

Some Lisps even have things called property lists which can be thought of as objects.

The real trick to using objects in a functional style is to make sure that you don't rely on their side effects but instead treat them as immutable. An easy way is whenever you want to change a property, just create a new object with the new details and pass that one along, instead (this is the approach often used in Clojure and Haskell).

I strongly believe that functional aspects can be very useful in JavaScript but ultimately, you should use whatever makes the code more readable and what works for you.

I wrote this blog engine from scratch using node.js. What makes this site different to the others running node.js is that this one is running completely off of a shared server (DreamHost, specifically).

When I was looking into using node.js, I found that most developers are deploying it by using the built-in web server and then optionally proxying it to Apache or Nginx. Those options just aren't possible when using cheap shared hosting. At this point I could:

1. Rent a virtual machine to deploy a node.js website (costs money)
2. Hack up a custom solution to make node.js server on a shared server (takes time)

I chose the latter and now I am the proud creator of the node-cgi monster. It's a CGI adaptor for node.js that mimmicks the node.js http library.

To use the adaptor you must create a .htaccess file that redirects paths to a CGI script. This blog uses:

Options +ExecCGI
AddHandler cgi-script cgi

RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule (.*) server.cgi

Where server.cgi contains:

#!/usr/bin/env node

var blog = require('./blog'),
    cgi = require('./cgi');

var server = cgi.createServer(blog.requestListener);
server.listen();

For people not familiar with node.js, using this library is very similar to the standard way of creating a HTTP server:

var blog = require('./blog'),
    http = require('http');

var server = http.createServer(exports.requestListener);
server.listen(5000, "localhost");

This means that some applications will only have to change require('http') to require('cgi') to create a CGI version!

The library is up on GitHub for those that want to take a look. I'd like to know if anyone finds it useful!