replicator.org ... incoherent code

So today I found out that Google released two new things:

A second life clone: Google lively!
And protocol buffers: A data structure specification language which people think it might replace XML, but I think the concepts are totally different.

I am a bit annoyed about Google, because they seem to grab anything out of the wild and try to implement it better, and I think they often fail, but surely kill off any competition in the process.

Did you know that implementing a mechanism similar to discriminated unions in C# or any other language that supports interfaces and lambdas is pretty simple?

The last three days I was visiting the conference Advanced Visual Interfaces in Naples, where a lot of interesting presentations were given. The most hyped technologies were tabletops using multi-touch interfaces. Some of the more advanced examples like the one from Austria, that mixed pen and multi touch gestures in surface based applications, were really stunning and reminded one more and more of the visions expressed in the movie Minority Report).

Recently I was reading a report from Alan Kay ‘s team, STEPS Toward The Reinvention of Programming: First Year Progress Report. And now I want to be sure you don’t miss it. This is definitely something going in to the right direction. It summarizes the current state of programming practices that effectively lead to less code and better working software. Toolboxes similar to OMeta, Katahdin will probably be found in every developer’s toolbox in a few years from now, especially if external DSL are used more often in projects to model the solution domain.

I am back on track to create the next generation user interface framework. Inspired by my newest gadget the IPod touch, usability gets – again – a high priority in my private research.

This blog entry is about functional composition, which I recently found a very important feature to be added to my C# development box. Requirements for a functional composition are closures and a lot of syntatic sugar that makes declaring functions fun.

I finally finished a pet project that I started in 1999 in Haskell and then ported it to C# at Easter last year.

The original motivation was to create a internal DSL to specify a parser directly from a syntax specification. I always felt that there must be a much more versatile solution to parsing lexical and syntactic grammars. The solution provided by the parser generators available never felt aesthetically appealing enough to be used for simple projects. I also never understood that the lexical scanning must be separated from the syntactical parsing.

Because of their simplicity, EBNF and relatives embrace a very powerful expressiveness, but why do I need to care for the implementation and performance? That’s what tools are for! As soon you want to pass your beautiful simple grammar to the parser generator, the sanity ceases and acronyms like LALR or LR() and shift reduce / reduce reduce conflicts pop up and many more details you’ve never heard of. Suddenly, you feel that you missed something, and it turns out that the answer for all your problems may be found by reading the dragon book, which essentially praises you to follow the dots and makes you feel that parsing is by ways too complicated. Whow! I just wanted to create an INI-Parser so that it is somehow reusable. This time again, you’ll implement it by hand in an hour or two, and so the world gets another trashy INI parser more.

May be it is about premature optimization. But when time passes by and Moore’s Law helps us to do anything we want as long we stay in the O(n) range, age old ideas are hype again and we finally can waste a lot of computing power, to, ...

This describes a live transactions, a concept similar to software transactional memory capable to replace model view controller.

Well, it seems to get a little more boring, but perhaps the more interesting sessions were all scheduled on the other days :) The talks we visited today are more of the philosophical nature. For one it is nice to see that there are important and recognized people thinking about the very abstract nature what software actually tries to accomplish, but compared to research papers these are simply out of this world and have – at least right now – no practical consequences at all.

Today we learned about the analogies between garbage collection and transactional memory. The similarities are astonishing.

Great, this year I finally made it to the conference that is really is about the core of software development. The Oopsla conference taking place in Montreal, Canada.