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.

Current progress:
Class & module definitions work correctly now, meaning that it now fully supports nearly all concepts that you find in Ruby. The main difference is, that in contrast to Ruby, Blocktalk does not have any real Keywords predefined, except for just a few including:

• def (for indicating method definitions)
• do & end (for codeblocks)
• self (the same as in Ruby & Smalltalk: reference to the current object)
• return (explicitly returning from withing the middle of a method)
• yield (same as in ruby: yielding to a given implicit block)
• Some literal syntax (not real Keywords, but somehow belongs into this category) for Arrays, Hashes, Codeblocks, Integers, Floats, Strings, Symbols, Characters and of course Assignment

That’s pretty much it, regarding predefined keywords in the language itself. Everything else relies on expressions like message passing (a.k.a. method calling) to objects, assignments and arithmetic. Even defining new modules or classes is done by sending a message to the Class or Module class-object (very similar to how it’s done in Smalltalk and how you can also do it in Ruby).

Here’s a small example of defining a class and a module:

Module >> :ModuleA do
  def method_a = do
    Console puts: "in ModuleA#method_a!"
  end
end
 
 
Module >> :ModuleB do
  def method_b = do
    Console puts: "in ModuleB#method_b!"
  end
end
 
Class >> :Place do
  def 1/>self from_city = do |city_name|
    # should do something useful here ...
    Place new
  end
 
  def coordinates = do
    # do some calculation here...
    return (Kernel rand)
  end
end
 
Class >> :Person do
  1/>self mixin: [ModuleA, ModuleB]
 
  # constructor with named params
  def initialize = do |name age: age city: city|
    @name = name
    @age = age
    @city = city
  end
 
  def go_to = do |place with: vehicle|
    ((place is_a?: Place) and: ((1/>self distance_to: place) < 10.5)) if_true {
      vehicle take: 1/>self to: place
    }
  end
 
  def place = do
    Place from_city: @city
  end
 
  def distance_to = do |place|
    (place is_a?: Place) if_true: {
      dist = ((1/>self place) coordinates) - (place coordinates)
      dist abs
    } if_false: {
      0.0
    }
  end
end
 
chris = Person new: "Christopher Bertels" age: 22 city: "Osnabrück"
city = Place from_city: "Berlin"
 
Console puts: "Distance from chris to city:"
Console puts: (chris distance_to: city)
 
# Person mixed in ModuleA & ModuleB:
chris method_a
chris method_b

I’m still tweaking a little here and there, but I think most of the standard language features are working now. Now I’ll try to come up with some more unique things. I do have a few ideas already, but I still need to see, if they really work out nice. Let’s see

Inspired by what Smalltalk and Ruby have to give, I started designing my own language, heavily influenced by those two great, very dynamic, truly object-oriented programming languages and came up with a quite simple language named blockd.

The name is based upon the main principle of the language: Everything is an object, and in the end, all code is defined within blocks – that are ruby / smalltalk like blocks. Naming these blocks is done via simple assignment. So instead of having a huge amount of keywords, the language itself is pretty simple, because all we really need is a way to describe assignments, instantiate objects and easily create blocks to pass to methods or use in an assignment.

So in contrast to Ruby, where there are procs, lambdas and blocks, blockd only knows blocks, which basically behave like Smalltalk like blocks – they simply are anonymous procedures / blocks of code (or functions, if you want to call them that – although not pure as in Haskell).

The syntax is a mix of Ruby’s and Smalltalk’s with some minor tweaks I thought would be cool (or not? I don’t know ).
To give you an example of how the language looks, here is a small snippet of some sample code, that actually doesn’t work yet but might do so in the future

# this is just for demonstration
# there probably won't be the need to require the console module from the
# standard library every time you want to print something to the screen ;)
System require: "console"
 
# we support ruby-style blocks with do ... end and curly braces { ... }
File open: "test.txt" mode: "w" do |f|
  f puts: "what's up, dog?!"
  f puts: "crazy shit, yo!"
  f puts: "hahaha!!"
end
 
10 to: 0 do |i|
  Console puts: i
end
 
i = 0
(i < 10) while_true: do |i|
  Console puts: i
  i incr
end
 
numbers = [1,2,3,4,5] select: {|i| i < 3}
numbers each: do |i|
  puts i
end
 
(1 .. 100) each: {|i| Console puts: i}
 
squares = (1 .. 100) collect: {|i| i * i}
 
# define a square method
square = { |x|
  x * x
}
 
# or like this:
abs = { |num|
  (num > 0) if_true {
    return num
  }
 
  num * -1
}

I’m still tweaking the syntax and haven’t decided upon all things completely yet, but I guess I’ve found the pretty basic “feel” of it.

While I haven’t shown you any code that defines a class or modules, it still does show a little of the languages syntax. I’ve started the parser today and it successfully parses the code above, meaning, that since the syntax isn’t too complicated, I expect to be able to parse all the remaining stuff (classes & modules and some minor other things) pretty soon. I then intend to start writing the actual implementation – an interpreter written in Ruby. While I could come up with my own runtime, class library etc, I want to make use of the Ruby infrastructure as much as possible. For one reason, it makes it easier to actually implement something useful, on the other hand, since the language is very close to Ruby’s object model and semantics, I hope I can use most of Ruby’s code directly. This also would mean, that the interpreter could also run on other Ruby implementations like JRuby, IronRuby etc. And maybe, some day, it could also run natively compiled with the Ruby compiler I’ve been working on recently as well – but that’s still far into the future, since the compiler isn’t finished yet.

I guess that’s it for now. More to come soon

I’ve been programming Lisp for a little while now and always have been looking for some video tutorials (or screencasts) about Common Lisp or Lisp programming in general but haven’t found so many.
Also doing some Ruby stuff, I always enjoyed the huge amount of videos online and thought that there should be more Lisp related screencasts as well.

So, I thought about starting my own. And here it is

You can download the Quicktime file here: Lisp Screencast #01: Macros

Or also watch it on my Blip.tv channel:

Any comments? Feel free to send me a mail or post a comment here.

I’ll try to make this a regular thing for the future. Any topic suggestions are also welcome.

It basically does the same as the predefined dolist-macro, but oh well

foreach macro

1
2
3
4
5
6
7
8
9
10

;; foreach-loop, similar to those in Java or C#
;; example: (foreach (x '(1 2 3))
;;                               (print x))
(defmacro foreach ((var list) &body body)
  `(let ((,var (car ,list)) (rest (cdr ,list)))
    (if ,var
	(progn
	  ,@body
	  (foreach (,var rest) ,@body))
	nil)))

I’ve also come up with my own file-handling macro, similar to the predefined with-open-file:

with-file macro

1
2
3
4
5

;; can be used like with-open-file macro
(defmacro with-file ((filestream-var filename &optional &key (if-exists nil) (direction :input)) &body body)
  `(let ((,filestream-var (open ,filename :direction ,direction :if-exists ,if-exists)))
    ,@body
    (close ,filestream-var)))

At first macros seemed to be something complicated, but once I’ve started reimplementing some of the standard macros and also making up my own custom ones, it really got much clearer to me how they work and why they are so important. Especially the with-file macro gives you an idea of whats possible with macros. Abstracting away the pattern of opening a file, doing something and then closing it again is just really nice, since you won’t ever forget to close it again, if you stick with using the macro.

I’ll try to come up with some more soon.

Next big thing on my agenda is some file in- and output as well as CLOS, the powerful Common Lisps Object System.

Here’s what I’ve done so far:

while macro:

1
2
3
4
5
6
7
8

;; example:
;; (defparameter x 0)
;; (while (< x 10) (print x) (incf x)) ;; output numbers 0 - 9.
(defmacro while (cond &body body)
  `(if ,cond 
    (progn ,@body 
	   (while ,cond ,@body))
    nil))

until macro

1
2
3
4
5
6

;; example: (until (= x 10) (print x) (incf x))
(defmacro until (cond &body body)
  `(if (not ,cond)
    (progn ,@body
	   (until ,cond ,@body))
    nil))

for macro

1
2
3
4
5
6
7

;; example:
;; (for ((i 0) (< i 10) (incf i))
;;      (print i))
(defmacro for (((var init-value) cond step-block) &body body)
  `(do ((,var ,init-value ,step-block))
    ((not ,cond))
    ,@body))

I started this yesterday and I’ll try to come up with some more. Lets see what else i can come up with
Not that this is particularly useful or anything since you really don’t need them, but it’s still a nice way to learn the language and especially how macros work. I’ll just keep it as a little exercise to myself in order to get to know common lisp in greater detail.