• A whole session, chaired by James Cheney, discussed bidirectional functions. The problem definition is: Given a function f from X to Y such that f(x) = y, synthesize a function g from Y to X, such that if y’ is similar enough to y then g(y’) = x’ and f(x’) = y’. Rephrasing for the modeling community: Given a code generation schema f, synthesize a model extraction schema g, such that if the code hasn’t changed too much, it can reflect the changes back to the model. The results in this field are still far from usable as-is (the restriction assumptions are still rather limiting). However, any progress in this track will be great.
• A repeating topic in those type theory talks were dependent types. A dependent type, if I understand correctly, is a type that is define by some computation, and not only in terms of its structure. For example, prime numbers are a dependent type. Some new programming languages (the favorite was Agda) actually support a type system with dependent types. That brings these languages closer to automatic theorem provers, such as Coq. If this trend continues, we’ll see a new programming paradigm emerging, at least as powerful as logic programming.
• Finally, “the most influential ICFP paper” for the years 2000 – 2010 was announced in this year’s ICFP. It wasn’t a type theory paper; it wasn’t a partial evaluation paper; it wasn’t about compilation at all. It was John Hughes’ paper about QuickCheck, a multilingual library for generating test cases based on properties. Later, at the Erlang workshop, John briefly discussed properties testing for parallel scenarios, and how it caught bugs in one Erlang’s standard library servers (!). That’s a result that cannot be ignored, given the raising importance of parallelism.

To cut a long conference short: Software Engineering is not just about OOP anymore.

I’ve encountered a few interesting posts recently, following Zohar Arad’s The Thinker Fail post on Newsgeek. Summing it up, Israel, once praised as “The Start-Up Nation”, is in trouble – We’re dragging behind as the web technology progresses. Causes:

1. The government, and hence the army, are biased towards Microsoft products (see Michael Eisenberg’s post). Therefore, the plethora of army-trained programmers are biased towards .NET technologies.
2. The universities and colleges teach web programming using .NET or Java.
3. The world, namely the silicon valley, has moved onward to open-source web technologies, like distributed cache and HTTP load balancing (thanks again to Michael Eisenberg for pointing that out).
4. Bottom line, Israeli students are not up-do-date with the technology required for building a scalable web application.

Zohar Arad claims that this is in part the fault of Israeli higher education, that puts too much focus on mainstream technologies. Please read the last sentence again: It is a cry from the hi-tech trenches for the universities to focus less on technologies, more on theory and methods, and let (even force) the students to study the rapidly-changing technological stack by themselves. After teaching students OOP and web programming for over 4 years now, I couldn’t agree more. However, it is not entirely the fault of the universities. Students often cry to high heavens when a lecturer switches from good-old mainstream programming languages to something else – Be it a functional programming language, a scripting language, or even just an open-source application. If it is outside the comfort zone of Eclipse (or visual studio) and Windows’ next-next-next installers, it’s too hacker-ish for many students’ taste.

In Israel, elitism is a sin against political correctness. Being in an elite, however, doesn’t necessary means demanding more from other; it means demanding more from yourself. I would like to address an elite group – As if getting accepted to a Computer Science program isn’t elite enough – The more motivated and driven students. No musician will achieve greatness without practicing on every single free moment, even if he (or she) studies at Juliard. Likewise, you can’t become a web entrepreneur just by doing the required minimum at a CS program. You have to go the extra mile yourself. Following Zohar’s shopping list to the letter is a good start.

See you all at the fall semester!

The Erlang standard library includes Mnesia, a distributed database library. It is a most useful application. To make it even more useful, it includes the Table Viewer (TV) – A Tk application that shows the content of Mnesia tables.

When I opened it, I was surprised to see that one of the options is “Error Messages in Haiku”:

When this option is checked, the viewer provides it’s-own Zen interpretation to various malfunctions:

This can be the beginning of a great geek-talk tradition, although I doubt how useful or informative it will be:

The reference X
Only seems to be valid;
But it points to null.

Programming began as a merry hackers’ hobby, and evolved into a quick way to make money – We saw two high-tech bubble bursts in the last 10 years to prove the second. Somewhere in the process, software sneaked into each and every piece of machinery that we have, from phones to war machines. However, the software industry never paused and reflected on how to take itself more seriously. People started to be afraid of machines (See the terminator and Matrix series for a proof), but they are pointing their fingers in the wrong direction. Machines don’t kill people. People who program machines kill people.

Btw, credit where it’s due: Reody Green saw it coming.  Read his wonderful article on “How to Write Unmaintainable Code” and the appendix “Operation Termite”.

Luckily, that specific scenario is actually possible – In SWI-Prolog, at least. The “call” meta-predicate, and its derivatives, may take a functor and extra arguments as parameters. Then, the extra arguments are concatenated to the arguments of the functor, and the resulting functor acts as a goal.

If this is all Prolog-Chinese for you, here’s an example:

Consider the following predicate:

is_child_of(Parent, Child) :-
  some_conditions...

It succeeds if the second argument unifies with a child of the first argument – Whatever that means.

Now, suppose you have a list of elements, and you want to find only those who are children of “foo”:

apply:include(is_child_of(foo), List).

There are many more ways to do this, but you get the idea: “call(is_child_of(X), Y)” is the same as “call(is_child_of(X, Y)“, which is the same as running “is_child_of(X, Y)“.

Addendum

Why did I said that Prolog is not yet a functional programming language? Because there is currently a debate in the SWI-Prolog mailing list about introducing lambda expressions as a part of Prolog. Paulo Moura even went ahead and introduced it as a part of Logtalk (see this section). There’s also Ulrich’s lambda library. Some people don’t really approve of this, but hey, no language feature is perfect.

Big Talk

I attended a talk a few month ago by Jeffrey Ullman. One of the slides includes a graph with circles and arrows. He explained that the circles are computers and the arrows are messages, and that the graph describes an algorithm. “An algorithm”, he said, “is how computers collaborate”.

If the great Jeffrey Ullman gives a new definition to algorithms, the rest of us mortals need to pay attention. The reason behind this new definition was that modern CS problems are just too big to fit into the main memory of a single machine. Finding frequent pairs in terabytes of data-sets or handling a rapid click-stream are just a couple of examples. If you want to be a part of the “big talk”, you need to be able to scale up – That is, to distribute.

Distribution is one of the strongest points in Erlang, hence the recommendation. Even if you don’t end up programming in Erlang for living, it’s worth studying the design and standard library of Erlang, with respect to parallelism and distribution. It represents an invaluable knowledge from many years of designing distributed systems.

Buy low, sell high

Erlang is still a manageable language. The syntax is minimal and the standard library is not too bloated. Even the open-source projects are still rather focused on exploiting the strong points of the language, rather than just re-implementing thing “in the language we love”. The Erlang community is still small and welcoming. In other words, you can still become an “Erlang professional” without having to go over gigabytes of documentation and dozens of books. If you do it now, you’ll be ready when distribution will be a must. I believe that the question “can you program several computers, or just one?” will start popping up in job interviews within a few years.

A simple and modern language

Erlang is a simple language: It’s just a functional language with a modules system and 3 extra operators for asynchronous message-passing. Such languages tend to be somewhat restricted – For example, try to find a GUI toolkit for Scheme.

Erlang is not restricted. You can get any modern framework that you like for Erlang: Web servers, web page generation, AJAX, document databases, GUI, unit testing, large-scale system testing – And the list is still growing. It was an absolute delight to see the demos in EUC, in which good-old functional programming scaled up into a fancy web application. It’s true that Lisp did it before, but Erlang does it well.

A hacker’s delight

To top on its other merits, Erlang inherited from its ancestors (Prolog and Lisp) a couple of hackers’ back-doors. It exposes its scanner, parser, compiler and loader to the public use, so tricks like intervening with the parsing and loading code dynamically are available. It might not be the prettiest code in the world, but it is still more elegant than textual code generation.

To summarise: I don’t want to say on which programming language I am putting a “strong sell” recommendation, but one language that I am putting my programming money on, is Erlang.

Most servers and clients in Erlang are implemented as named procedures in named modules.  Similarly, processes communicate via named messages.  This exposes and fixes a great deal of information about an Erlang application: The names of the modules, procedures, messages between servers and clients, etc.  This talk explores how to gain anonymity through the use of anonymous higher-order procedures.

To spawn a process on a node, one must either to use a module name and a function, or to pass an anonymous procedure.  In order to use a function from a module, the module file must be available on the remote node.

For a server to receive many messages, the spawned function must be recursive. Recursive functions are typically implemented in Erlang via a name in a module. Running such a server requires that the client be aware of the names of the module, function, and messages.

Functional programming languages (such as LISP, Scheme, and Erlang), permit recursion to be replaced with self-application, which means functions that are applied to themselves.  This is a classical technique from functional programming.  In Erlang, this technique adds flexibility, anonymity and security.  Specifically, we demonstrate how to

• Spawn a fully-functional server without requiring shared modules or access to  the file system.
• Have client-server groups that take the message names as arguments.
• Use random and constantly-changing message names.

See you there!

No-one is more dangerous than the supervisor of a failed system, who abandons the system, but keeps the loot: A position of power.

I saw that quote on the 1956 anti-communist students’ rebellion memorial in Budapest. (read: Buda-pesht. There is no such city as “buda-pest”. It’s a transliteration error.)

Without mentioning names, I can think of several engineering and programming practices that can fall into this category: Mistakes that are too collosal to admit; Practices that give power to the supervisor but no merit to the practitioner.

In the spirit of Tom Gilb, any development method should by itself be subject to development. Keep that in mind next time someone declares “the ultimate programming methodology” or “the last programming language we’ll ever need”.

(Btw: COBOL has just celebrates its 50th birthday.)

You couldn’t get it more wrong.

Prolog is a programming language that has a specific domain. Just like SQL and relational databases, Perl and text processing, Erlang and distributed computing, Java and over-sized, badly-designed on-top-of-a-technological-stack-higher-than-the-empire-state-building so-called “enterprise applications” — Prolog is about facts and deduction rules, under the closed-world assumption. Its true that you could use it to manipulate general-purpose data structures (just like you can write one-off text processing scripts in Java) — But it’s not intended to. Prolog read facts and produces more facts using deduction rules. That’s it.

You might ask yourself “What’s that good for?”. Admittedly, the textbook examples are awful. We all know that the brother of your father is your uncle, and so on, there’s no real necessity to apply artificial intelligence technique to get that. Also, the “closed world” thing makes Prolog less applicable for general application development. However, there’s one domain that is made exactly of facts and rules in a closed world, and that’s were Prolog hacking is:

Software.

Requirements and implementations, problem domains, design models and source code, are all finite-sized sets of facts. Who-calls-who, what-implements-what and were-did-that-code-go are all queries on top of the closed world of a software project. Implementation patterns are deduction rules, and that’s just from the top of my head.

The most obvious evident to that trick is the fact that Prolog is the one language that does not need a fancy IDE, since that code (i.e., predicates with body) is treated in the exact same way as facts (i.e., predicates with no body). SWI-Prolog supports the following IDE-like predicates built-in:

• List the current predicates
• Cross-reference between predicates (i.e., who-calls-who)
• Online help on a predicate
• Predicate properties (arity, source file, line number, content)
• List a predicate
• Open a predicate in your favourite editor
• Find predicates with a similar name to what you typed (the DWIM predicate – “Do What I Mean”)

It’s true that most IDEs know to do exactly that, but Prolog itself knows too: It just taps its-own database.

Using this power for software modeling is another thing, and that’s more-or-less my next line of research, so more on that to come.

(Btw, I know I haven’t written in a while, but neither did Shakespeare, and he did not have to grade two exams and go on  reserve duty.)

Why is that? Even the notoriously hoggish IntelliJ IDEA 8 doesn’t take that much RAM. I don’t know for sure how comes Eclipse became the new memory hog in town, but I have a guess: It has something to do with EMF.

EMF stands for “Eclipse Modeling Framework”. It’s the underlying layer that enables all those nice property sheets and graphical editors. Basically, it adds highly-detailed reflection to Plain-Old Java Objects (POJOs) by generating a massive amount of code. This reflection is needed for auto-generating all that fancy GUI, but it requires supporting data structures – And that shows up on the system monitor.

(Btw, if you’re willing to pay the price for reflection, why not use a language that have native reflection, such as Python, and get rid of those code-generated monstrosities? Just a thought.)

No solution this time. It is a ranting post.