Programming

Language improvements

hamilton verissimo — Sun, 05 Feb 2006 06:06:00 GMT

So among one phase and other of Manhunt, I'm improving my brain exercise. Now it's able to deal with boolean expressions. I had to review the AST nodes implementation to allow some tree rewriting.

a = 1 == 1 
b = 1 != 2
x = 10 
puts 3 * 90, a, b, x

This produces the following initial AST

AssignmentExp
  NameReferenceExpression (a) 
  BinaryExp (....)

AssignmentExp
  NameReferenceExpression (b) 
  BinaryExp (....)

AssignmentExp
  NameReferenceExpression (x) 
  ConstantExp (10, int)

MethodInvocationExp
  Target NameReferenceExpression (puts)
  Arguments
    BinaryExp
    NameReferenceExpression (a) 
    NameReferenceExpression (b) 
    NameReferenceExpression (x)

So I'm treating the names as some unknown entity that is rewrite as we discover more... The tree gets rewritten to

AssignmentExp
  VarRefExp (a) 
  BinaryExp (....)

AssignmentExp
  VarRefExp (b) 
  BinaryExp (....)

AssignmentExp
  VarRefExp (x) 
  ConstantExp (10, int)

MethodInvocationExp (puts)
  Target null
  Arguments
    BinaryExp
    VarRefExp (a) 
    VarRefExp (b) 
    VarRefExp (x)

The code, once executed produces:

E:\dev\projects\Blah\BlahProj\bin\Debug>hello
270
True
True
10

Kinda cool. Now I'd like to introduce the dynamics capabilities, meaning: some names should be marked as dynamic, and thus the compiler should not attempt to type it and consequentially more code will be generated in order to perform checks and casts. It's kinda fun, but demands too many types to get something running :-\

Type inference and polymorphic functions

hamilton verissimo — Sat, 04 Feb 2006 03:51:00 GMT

I've been using my spare time to read about different languages and how they deal with types. It's amazing how good ideas are implemented in several non-mainstream languages that are not going to ever be known by most of programmers.

Nevertheless, you can deduce that I'm working on a language. Indeed, just as a brain exercise. Fixing and improving Castle is nice and it's cool, but sometimes I need to research and try things on a different field. One of the things I wanted to make work was type inference, but the sophisticate version of type inference.

The non-sophisticate type inference is being able to type designators based on the assignment expression, like

myvar = 10 + 15

The binary expression will be evaluated to int, and so is myvar. This does not consider others usages of myvar on the same context. For example:

myvar = 1

if (myvar > 10L)
...

Here, while myvar will be typed as an int, it's being used in a comparison with a long.

There are many paper on type inference for object oriented programming languages, quite interesting subject. Most of them care about polymorphic function as a mean to achieve efficient code and thus optimized execution.

The quite trivial example would be

def max(a, b)
  if (a <= b) b else a
end

max(1, 2)
max(10L, 20L)
max(3.01, PI)

Type inference will be used here to create three versions of the same max function. Some papers suggest the usage of constraints inequalities to solve types and to create the versioned functions in this case. This involve creating a graph based on code flow where the nodes represent the variables and the edges represent the constraints:

myvar = MyClass.new  # Constraint: myvar should be at least as subset of MyClass type

Anyway, a very sophisticate type inference may be found on ML. The book "Programming language pragmatics" has a great topic dedicated to it. Using its example code:

fun fib (n) =
    let fun fib_helper(f1, f2, i) =
        if i = n then f2
        else fib_helper(f2, f1+f2, i+1)
    in  
        fib_helper(0,1,0)
    end;

The syntax is quite strange, isn't it? I've never programmed in ML, neither any other functional or imperative-functional language. But the beauty here is the type inferencing working

The parameter i should be int as it's been used in a binary expression with another int. Parameter n is compared to i, so it must be int too. When fib_helper is invoked in the body of fib function, the parameter are also int, so this is consistent with the inference so far. Any usage that is not consistent will raise an error.

Isn't that cool or what?

Anyway, for now I'm going to stick with a non-sophisticated version, unless I bump into a nice paper describing a very simple algorithm that fits my needs.

Btw Nemerle is a language to be checked. I'd never use it to construct a system, but it's quite nice to force a shift in your brain. The virtualization of structural types that they achieved is impressive. If you don't know what that means, in most languages type equivalence is based on what a type have

record x
  int i,j
end

record y
  int age, favcolor
end

In lots of programing languages, x and y are equivalent. Java and .Net use names to determine equivalence.

On Nemerle (copying from their tutorial) they have (and you can create your own) methods that depend on a signature

class Hashtable ['a, 'b] 
{
   public Iter (f : 'a * 'b -> void) : void 
   { ... }
}

Here Iter is a function that expects a function with the signature of 'a, 'b and returning void.

Well, there are many programming languages around. Each has distinct features and cool and nasty stuff. So my word of advice: get out of the mainstream driveway every now and then and see what's happening around. You won't regret; :-)

Btw Mike has cast his vote towards a 100% dynamic language. I'm really not convinced about that and still leaning towards a hybrid solution.

Weekend experiences

hamilton verissimo — Sat, 28 Jan 2006 23:31:00 GMT

I was able to compile and run the following code

x = 10
x = x + 1

Yeah, stupid, innit? You may look closer and realise that

'x' is an undeclared variable
'x' type is thus not defined
'x''s type is inferred based on operations of attribution that follows the first appearance

So x goes to a SymbolTable. Every assign expression that uses it is registered as a candidate on the SymbolTable entry. During the type resolval step it's easy to resolve the type of the first assign:

x = 10 # this is a int32 constant, nothing to compute here

Now the second is trickier:

x = x + 1

We're now trying to infer the type of a variable based on an expression that uses it.

Anyway, this is something I need to research more. My naive implementation is shameful.

The IL code generated is:

.method public hidebysig static void xpto() cil managed
{
      .entrypoint
      // Code Size: 15 byte(s)
      .maxstack 2
      .locals init (
            int32 num1)
      L_0000: ldc.i4 10
      L_0005: stloc.0 
      L_0006: ldloc.0 
      L_0007: ldc.i4 1
      L_000c: add 
      L_000d: stloc.0 
      L_000e: ret 
}

Which as you can see doesn't have even the minimum of optimization, which should produce

.method public hidebysig static void xpto() cil managed
{
      .entrypoint
      // Code Size: 15 byte(s)
      .maxstack 2
      .locals init (
            int32 num1)
      L_0000: ldc.i4_s 10  # within a byte range, use the short form
      L_0005: stloc.0 
      L_0006: ldloc.0 
      L_0007: ldc.i4_1     # same thing
      L_000c: add 
      L_000d: stloc.0 
      L_000e: ret 
}

But still better than the version produced by IronPython :-P

I'm still not convinced about construction a 100% dynamic language. A hybrid would be best, but I'd like to hear opinions.

Laptop upgraded

hamilton verissimo — Fri, 27 Jan 2006 19:44:00 GMT

So I finally upgraded my laptop memory and have it cleaned (coolers and processor). Now 1GB + 256mb should be enough to ReSharper. Gosh, that thing is a memory eater. I wonder whether there are memory leaks on the code. It won't surprise me, though. ReSharper seems to use lots of flow analyzers which are quite complex.

Anyway, one day and a half without any computer or internet access was surprisingly good. I had a chance to pile all the books I wanted to read and just sit and start reading them. The downsize was that half of them were technical books, so I urged to practice what I've learned. Well, experimentations are due to the next weekend.

New blog

hamilton verissimo — Wed, 25 Jan 2006 16:31:00 GMT

This one seems nice. My old blog unfortunatelly has been taken over by spammers, I had to disable comments and couldn't stop to delete all the spam (it was hundreds, maybe thousands of spam comments)

Today I read an interesting sentence (two to be precise) from StringTemplate documentation:

Many tool builders have clearly lost sight of the original problem we were all trying to solve. We programmers often get caught up in cool implementations, but we should focus on what should be built not what can be built.

I couldn't agree more