I’ve been up to a lot of stuff in the past few months. Related to programming there are two projects, one of them I’m still working on (and intend to do so for the forseeable future):

• generica, a small, simple & dirty lisp-like language interpreter implemented in ANSI C.
• and Fancy, a new object-oriented dynamic programming language, heavily inspired by Ruby, Smalltalk and Erlang. There’s also a website up, but far from finished: fancy-lang.org – Check it out if you like

So yeah, the latter project I started about 6 weeks ago but didn’t have the time to really work on it until about 3 weeks ago. Since then I’ve managed to implement quite a few features.
Here’s a small overview of features working in Fancy already:

• Class definitions
• Method definitions
• String, Integer, Double, Array, Hash (Hashmap), and Block (lambda function / closure) Literals
• Method and operator calls (sending messages to objects)
• Simple loops
• Support for closures (performance improvements are definately possible though )

There’s still lots of stuff missing, obviously. Mainly most of the standard library (I/O, Threading/Concurrency, Networking, etc…) will have to implemented as well as some runtime features I haven’t finished or started yet. But it’s getting along quite nicely. If anyone dares to try it out, I’d love to hear some feedback, especially hearing some opinions on the overall feel and semantics of the language would be nice. You can get the code on github (see the link above) and try to build it. Compiling instructions are in the README file. Fancy is licensed under the GNU LGPL.

I’m still excited to see where this is gonna go, for myself and possibly others as well. We’ll see.

I’ll probably post some more information on the language and its implementation some time soon. Need to go now.

For now, the interpreter is able to understand & execute methodcalls on objects, anonymous methods (blocks & procs in ruby) and some other minor stuff.

Heres a small example, that actually works now:

y = { |x|
  Console puts: x
  Console puts: (x * x)
}
y call: 10
 
m = { |x y|
  Console puts: ((x upcase) * y)
}
m call: "cool " y: 10
 
square = { |y|
  y * y
}
cubic = {|x| (x * x) * x}
 
3 times do |i|
  Console puts: i
end
 
foo = {
  3 times { |i| Console puts: (square call: i) }
}
 
Console puts: "--"
 
foo call
 
10 times &foo

This basically is equivalent to the following ruby code:

y = Proc.new{|x| Console.puts(x);Console.puts(x.*(x))}
y.call(10)
 
m = Proc.new{|x,y| Console.puts(x.upcase().*(y))}
m.call("cool ", 10)
 
square = Proc.new{|y| y.*(y)}
cubic = Proc.new{|x| x.*(x).*(x)}
 
3.times(&Proc.new{|i| Console.puts(i)})
 
foo = Proc.new{3.times(&Proc.new{|i| Console.puts(square.call(i))})}
 
Console.puts("--")
 
foo.call()
 
10.times(&foo)

Now, to make this clear: The ruby code above is what the current interpreter actually executes. The way I’ve implemented it for now (and for simplicity only – just to get something working first) is, that it simply parses the blockd code and translates it into equivalent ruby code, which then gets executed via eval in ruby.
Now I know, this isn’t the best way to do it, for several reasons:
Normally, an interpreter executes the code it gets fed directly, expression for expression, as this is also the case for ruby. If you have an syntax error within the code that is evaluated, the interpreter usually notices this only at the moment it reaches that part of the code and tries to evaluate it. This isn’t the case for the current interpreter I wrote here. The reason I chose to do it this way, was that I wanted to get something working as possible. I do want to change it though later on, so that each expression gets executed on the fly, once it is parsed.

So for now, i evaluate the parsetree, and each expression node gets turned into a string of equivalent ruby code, that then gets saved in a global list (within a class called Evaluator). When the parser has done it’s job and all the values (strings of ruby code) of all expression nodes have been accumulated, i simply run ruby’s eval on it and at that point do the actual evaluation (and possibly get semantic errors here – like missing variables etc.).

I still need to implement some stuff regarding classes & modules, but I’m quite happy for now, since it wasn’t so hard as I had expected before. Once I have everything working, I’ll start to actually rewrite the parser in a way, that it evaluates & executes code on the fly, expression per expression and not all of them at once at the end. This should also improve performance, which is obviously another downside of my current approach, since I have to wait for all expressions being parsed & evaluated to appropriate ruby code first, before even beginning the actual evaluation process…

For anyone, who is interested, here is a simple benchmark of the code above:

The blockd version (executed with my current interpreter):

real 0m0.264s
user 0m0.184s
sys 0m0.072s

The ruby version of the equivalent code (generated by my parser):

real 0m0.021s
user 0m0.008s
sys 0m0.008s

As you can see, there’s quite a performance overhead. Although not really noticeable by a viewer, the numbers tell the story. So I expect quite an improvement in performance, once I’ll start rewriting the interpreter in the way I’ve mentioned above. Still cool though, if you ask me

So yeah, Erlang is fun. It’s really easy to learn, if you ask me. If you know some Prolog, that’ll definately help a bit, since Erlang is influenced by it. But even if you’ve never heard of Prolog before, the language in itself is really small and easy. Just a few concepts you’ll have to learn including those of message passing style concurrency with processes instead of shared memory threads and mutable state. The syntax might seem weird at first, but I found this to be no real burden in the end.

eFreeTPd isn’t finished yet, but I’ll keep up development. It shouldn’t take too long though until there’s a somewhat stable or functional version out

Next time I’ll write a little more on how eFreeTPd actually is implemented in terms of what design and overall structure is used.

I’ve been trying out Clojure lately. Clojure is a new lisp dialect, that is hosted on the JVM and interoperates nicely with it. You can easily use Java methods, classes and libraries. I’ve been using it a little bit, watching some videos about it on blip.tv by it’s author, Rich Hickey, which really is a brilliant guy. You should check them out as well, they give you a pretty good introduction to the language.

Compared to Common Lisp, which I really like allot as well, Clojure does feel a little bit more modern. For example, being not limited to reader support for lists, but also having maps and vectors (like arrays) as first class citizens, is really nice. And then theres the huge emphasis on multithreading support in a really nice way without locks and condition variables but with a stm (software transactional memory). Clojure is a functional language and focuses on immutability of data structures compared to Common Lisp, which also allows a more imperative style, if you want to. In Clojure, you’re forced to a functional style, which might seem like a downside at first, but which makes it possible to have some pretty neat features concerning multithreaded programming support. Since all the datastructures are immutable, there’s no need do use locks when having multiple threads sharing them. I suggest checking out the videos and to give Clojure a try. It seems very promising and it’s having quite a publicity boost right now. Just google for it, take a look on some mailinglists or checkout reddit etc. You’ll find plenty comments, links and blogposts about it (like this one ).

So since I thought it’s always nice to try to port an existing little application from a language I already know to a new one I want to learn, I tried to port a very small programm CallToPower, a collegue from university, wrote and posted on his website. I pretty much copied it straightly to Clojure, changing some parts.

Now I know this might not be the best way to write it in Clojure. But it was my real first (although very small) programm in Clojure and I wanted to make it as close to the original, as possible. Basically, what it does is display some values of some system properties you can choose by pressing the appropriate. Nothing fancy, but it shows some Clojure related stuff pretty well.

So here’s the code, use it as you like:

(ns sysinfo
  (:gen-class)
  (:import (java.awt BorderLayout
		     GridLayout)
	   (java.awt.event ActionEvent
			   ActionListener)
	   (javax.swing JFrame
			JPanel
			JLabel
			JButton)))
 
(def *x-coord* 30)
(def *y-coord* 30)
(def *width* 800)
(def *height* 230)
(def *prog-name* "SysInfo 1.0 [Clojure]")
(def *visible* true)
(def *resizable* true)
(def *frame* nil)
 
(def *label-property-mappings*
     { "OS Name" "os.name",
       "OS Architecture" "os.arch",
       "Java Classpath" "java.class.path",
       "Java Version" "java.version",
       "Current working directory" "user.dir",
       "Resize to default" "Resize to default",
       "Clear" " "})
 
(defn resize-frame
  [frame a b awidth bheight]
  (doto frame
    (.setBounds a b awidth bheight)))
 
 
(defn set-label-text [label text]
  (doto label
    (.setText text)))
 
(defn button-listener
  "Returns a ActionListener, which sets the text of the content label (label-content)
  to the appropriate system property (System.getProperty)."
  [property label frame]
  (proxy [ActionListener] []
    (actionPerformed [evt]
		     (let [system-property-value (. System getProperty property)]
		       (if (not (.equalsIgnoreCase property "Resize to default"))
			 (if (not (.equalsIgnoreCase property " "))
			   (set-label-text label (str (.getActionCommand evt) ": \n" system-property-value))
			   (set-label-text label property))
			 (resize-frame frame *x-coord* *y-coord* *width* *height*))))))
 
 
(defmacro doto-each
  "Macro, that works like doto-macro, only that it does it for each object in objects.
  varname is bound to each object in turn inside of the body (forms) and can be used to access the current
  object, if needed."
  [[varname [& objects]] & forms]
  `(do
     ~@(map (fn [f] `(let [~varname ~f]
		       (doto ~f
			 ~@forms)))
	    objects)))
 
(defmacro add-each
  "Macro, that calls .add on to-object with each object in objects."
  [to-object [& objects]]
  `(do
     ~@(map (fn [o] `(.add ~to-object ~o))
	    objects)))
 
(defn create-new-sysinfo-window
  "Creates the main form and returns it. Mainly GUI-related stuff (javax.swing)."
  []
  (let [frame (JFrame. "Adztec-Independent.de: SysInfo Clojure-style!")
	panel-header (JPanel.)
	panel-main (JPanel. (BorderLayout.))
	panel-left (JPanel. (GridLayout. 6 1))
	panel-south (JPanel. (GridLayout. 1 1))
	;; labels
	label-header (JLabel. "System Information")
	label-blank (JLabel. " ")
	label-content (JLabel. " ")
	label-adztec-indep (JLabel. "by www.adztec-independent.de")]
 
    (.setHorizontalAlignment label-blank (JLabel/CENTER))
    (.setHorizontalAlignment label-adztec-indep (JLabel/CENTER))
 
    ;; buttons
    (let [btn-java-cp (JButton. "Java Classpath")
	  btn-java-version (JButton. "Java Version")
	  btn-os-name (JButton. "OS Name")
	  btn-os-arch (JButton. "OS Architecture")
	  btn-current-working-dir (JButton. "Current working directory")
	  btn-resize-to-default (JButton. "Resize to default")
	  btn-clear-all (JButton. "Clear")]
      (do
	;; add button-listener to all buttons
	(doto-each  [btn [btn-java-cp
			  btn-java-version
			  btn-os-name
			  btn-os-arch
			  btn-current-working-dir
			  btn-resize-to-default
			  btn-clear-all]]
 
		      ;; add listener to button
		    (.addActionListener
		     (button-listener (get *label-property-mappings* (.getText btn)) label-content frame))))
 
	;; add buttons to panel
	(add-each panel-left
		  [btn-java-cp
		   btn-java-version
		   btn-os-name
		   btn-os-arch
		   btn-current-working-dir])
	(add-each panel-south
		  [btn-resize-to-default
		   btn-clear-all])
 
	;; add labels to panel
	(add-each panel-header
		  [label-header
		   label-blank])
	(.add panel-south label-adztec-indep)
 
	;; pack on frame
	(let [content-pane (.getContentPane frame)]
	  (add-each content-pane
		    [panel-main
		     label-content])
	  (doto content-pane
	    (.add BorderLayout/NORTH panel-header)
	    (.add BorderLayout/WEST panel-left)
	    (.add BorderLayout/SOUTH panel-south)))
	(doto frame
	  (.pack)
	  (.setTitle *prog-name*)
	  (resize-frame *x-coord* *y-coord* *width* *height*)
	  (.setVisible *visible*)
	  (.setResizable *resizable*)
	  (.setDefaultCloseOperation JFrame/HIDE_ON_CLOSE)))
    frame)) ;; return frame
 
 
(defn -main
  "Main function. Gets called by the system, if used as an executable .jar file."
  []
  (let [*frame* (create-new-sysinfo-window)]
       (. Thread (sleep 100))))

The problem with anonymous lambda functions is, that they can’t call themselves recursively, since – well they’re anonymous and hence don’t have a name. To get passed this problem, you can let it have an additional function parameter which it will call in place where the recursion would normally take place.

An example for a reverse function, which reverses the elements of its argument (a list) with the help of an accumulator list (which holds the reversed list) could be written like this, without using an additional function:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list &optional (acc nil))
  (let ((head (car list)) (rest (cdr list)))
    (cond
      (head
       (cond
	 ((atom head)
	  (myreverse rest (cons head acc)))
	 (t
	  (myreverse rest (cons (myreverse head) acc)))))
      (t
       acc))))

But, as you can see, the accumulator list is part of the function’s argument list, although optional. To make this function a little bit ’safer’, it shouldn’t be part of the ‘public interface’ of the function. So you’d probably come up with something like this, where you’d use an anonymous helper function, which takes the additional accumulator list and returns it when it’s done reversing the original list:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list)
  (let ((reverse-acc #'(lambda (func list acc)
			(let ((head (car list)) (rest (cdr list)))
			  (cond (head
				 (cond ((atom head)
					(funcall func func rest (cons head acc)))
				       (t
					(funcall func func rest (cons (funcall func func head nil) acc)))))
				(t
				 acc))))))
    (funcall reverse-acc reverse-acc list nil)))

But, as you can see, since anonymous functions can’t call themselves recursively, you need to give it another extra parameter, a function object, which actually gets filled with the anonymous function itself, so it can call itself inside its body. But, fortunately, theres an even better version how to do exactly this in lisp: With the labels special operator, which defines local functions with a given name (like normal functions) which can then get called inside the function body itself and in the body-form of the macro:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list)
  (labels ((myreverse-acc (list acc)
	     (let ((head (car list)) (rest (cdr list)))
	       (cond (head
		      (cond ((atom head)
			     (myreverse-acc rest (cons head acc)))
			    (t
			     (myreverse-acc rest (cons (myreverse-acc head nil) acc)))))
		     (t
		      acc)))))
    (myreverse-acc list nil)))

As you can see, this version is nicer than the first or the second, since it hides the fact, that the reverse function uses an accumulator list and that it is also easier to understand, since you can use an actual name for the function instead of passing the function as an argument to itself, in ordner to make a recursive call. So basically, you can think of a function defined with the labels special operator as a local defun, which I think is really nice.