H3RALD : Feed

Personal Log - June 2009

h3rald@h3rald.com (Fabio Cevasco) — Mon, 29 Jun 2009 02:24:00 -0000

Welcome to yet another of my extremely boring, excessively fragmented personal log posts. I’m seriously thinking of dropping the whole series in favor of more frequent (and shorter) blog posts, starting from next year. This means you’ll probably have to read another six of these priceless gems, until december 2009. As usual, feel free to skim through as each of the following sections is almost completely unrelated to the others.

H3RALD Web Site v8.0

It’s the time of the year, again. It doesn’t happen every year but it’s definitely a trend (hence the high version number): I’m going to redesign & redevelop my web site.

This time is not the usual “Let’s pick another language and another framework and start from scratch”, but a rather more radical shift, and yet at the same time less painful. The idea is to transform H3RALD.com into a 100% static web site, without losing anything in functionality (gaining, if anything!).

Tom Preston-Werner is definitely not the first person to blog like a hacker, and his very own Jekyll is definitely not the first static web site generator our there, nevertheless, he inspired me to embrace what seems to be one of the latest trend in developer’s blogs.

The idea is simple: turn all the blog posts and pages into static content, and rely on third party web services for things like comments, search etc. For a rather extreme by very interesting example, see Tagaholic.

The advantages of this approach are many:

Free yourself from a database.
Free yourself from a resource-hungry, server-side app (Typo, in this case).
Increase speed and reliability, without using caching or similar artifacts.
Keep everything under version control.
Don’t worry about breaking things when upgrading (even if the static content generator changes, it shouldn’t really break things).
Unleash the power of client-side scripting (namely, JQuery).

For now, I’m just brainstorming a little bit on GitHub, feel free to participate. The first step is obviously choosing a static content generator, and atm Jekyll seems to be slightly ahead of Webby. Opinions?

Glyph

Did you ever want to write a short manual or a book, or even a long article? If so, chances are you gave LaTeX a shot and either fully embraced its philosophy or totally refused it. Sadly, I belong to the second category: I believe sequential documents like manuals or books should be easier to create simply by using HTML.

Whever I have a chance to actually start working on it, Glyph will become a document authoring framework, i.e. a way to create visually appealing documents in a simple way. All the ingredients are there, it’s only necessary to glue them together in a pretty form:

Textile (and RedCloth) to produce clean HTML code from a human-readable markup
CSS3 to specify page rules
A few rake scripts to produce a standalone HTML file, TOC, Index etc.
An internal DSL for the document structure and metadata
Liquid for control flow, snippets and filters
PrinceXML to generate a PDF from HTML

This project is still in planning stage, feel free to have a look at the issues/features page on GitHub. Feedback is appreciated, as usual.

Vim files & the Stash

If you read the previous two sections of this post, you may have noticed that I’m growing more and more fond of git (and GitHub). Besides the repositories I already mentioned earlier on, I also created a personal stash, which I’m using mainly to store some of my Linux dotfiles, article drafts and …Vim customizations.

If you’re looking for a color scheme for Vim, check out my very own herald.vim, and tell me what you think.

Getting ready for the Big Step

This will probably be my last post as a free man, as I’m getting married (civilly) on July 2nd and (religiously) on July 11th. Luckily the photographer agreed to give us a CD with all the pictures taken on the big day, with no copyright restrictions attached to it (believe it or not, some photographers don’t allow you to republish your own photos unless you ask them first), so I’ll probably write a long post with pictures when we come back from our (half) honeymoon.

Everything is pretty much organized. We had troubles with the waistcoats we got from eBay: they were cut almost randomly to resamble waistcoats, but they weren’t so we had to re-order another lot of 7 sets (waistcoat, cravat and shirt this time) from another seller, this time UK-based. I seriously hope to get them in time.

On the 24th we’re having a party at our house. If you were invited, feel free to drop by, otherwise be prepared to be thrown out of the window (4th floor) by one of our ushers (Roxanne’s big brother). It’s probalby going to be about 30-40 people in the end, mainly because most of my office can’t come due to holidays they booked in advance.

What’s left to do now? Well:

Send the bomboniere over to Ireland
Make sure my dad actually ships the 96 specially-bottled bottles of our own wine to uncle John, in Ireland.
Make sure uncle John doesn’t drink all the 96 bottles of wine before the wedding reception.
Make sure my best man understood that the speech he has do make must be in English, at least 3 minutes long and not too offensive to the groom.
Pay a huge, colossal heap of money for the whole thing. It’s going to cost us (and my dad) quite a bit, in the end. But it’s a once-in-a-lifetime experience, after all (getting totally trashed in a fancy hotel with all your family, including 2nd and 3rd grade cousins).

Herald (Vim Color Scheme)

h3rald@h3rald.com (Fabio Cevasco) — Wed, 17 Jun 2009 06:11:00 -0000

I use Vim a lot. It’s my editor of choice when I code (mainly in Ruby), and also when I write my blog post and articles (mainly in Textile). One thing I always liked about Vim was it powerful syntax highlighting: there’s probably a syntax highlighting file for every programming language ever created, even the new ones (Nimrod? Sure, here!).

Furthermore, Vim allows you to create color schemes, and that’s surprisingly easy to do. Everything you need to do is in the docs, but that may put you off, so you can just start by editing an existing one—that’s what I did.

InfiniteRed Black

I’ve been using the ir_black color scheme for near enough a year. It’s an excellent color scheme, recommended especially for writing Ruby code:

I honestly thought this was the best Vim color scheme until I discovered Moria…

Moria

Recently I switched to moria, mainly because I find it easier on the eyes. It’s a matter of taste, of course:

The trick is in the background: it’s not completely black. Still, I didn’t quite like the colors, so I decided to write my own…

Herald

Meet herald.vim (this is a direct link to the raw file, but you may also want to check my stash on GitHub or the script page on Vim.org):

To sum up, here’s the features offered by this new color scheme:

It’s easier to differentiate syntax elements; in particular reserved words like if or end, constants (symbols) and identifiers (instance variables).
Operators are highlighted and easier to notice.
Dark gray background and black column/row selectors.
Added highlight for titles (useful for Textile)
Comments do not stand out, unlike in most color schemes
Support for 256 color terminal (special thanks to Wolfgang Frisch for providing all the info and tools required)

So what do you think? Is it tool colorful perhaps? How would you improve it?

Personal Log - May 2009

h3rald@h3rald.com (Fabio Cevasco) — Sun, 31 May 2009 06:35:00 -0000

Yet another extremely busy month, as you can see from the total absence of blog posts and lack of tweets even. Things are getting pretty hectic at work now I guess: less people, more work, more responsibility, same money. They call it contingency; it’s the latest trend in the Western World, didn’t you know? I’m really not impressed. I can’t complain though I guess: I still enjoy my job very much and I know it could be much worse, so it’s just a matter of enduring until autumn—or so they say.

Star Trek Premiere

The month started with an event I’d been looking for for months: the premiere of Star Trek XI, aka “Star Trek”. It’s not that J.J. Abrahms couldn’t come up with a more original name (Star Trek: Academy used to be the working title, at one point), he simply wanted to tell the world that this movie was a new beginning, an elaborate way to start from scratch, to reboot what was more than once dubbed a dying franchise.

The movie was enjoyable – daring and a bit flamboyant – but still enjoyable nonetheless. I consider myself a Star Trek fan, and although it was not the usual Star Trek movie, I somehow liked Abrahms’ bold revisitation of Roddenberry’s universe. Take a bunch of unknowns (Chris Pine) or semi-unknowns (Zachary Quinto), then add some spicy British humor (Simon Pegg) and some old friend (Leonard Nimoy) and throw in an awful lot of XXI century special effects: what you get is not the usual, let’s-all-rock-because-we’re-hit traditional Star Trek, of course, it’s an alternate version of it.

That’s precisely what the movie is meant to be: what Star Trek would have look like if it had been created in the XXI century. The timeline feels disrupted since the very first minute (nevermind the end!), with a Jim Kirk stealing his stepfather’s car. Chris Pine is an [alternate)] Kirk, quite different from the original one, but not that bad. Zachary Quinto, on the other hand, is a true revelation: he definitely is the new Spock, and he couldn’t have been cast better. So is Simon Pegg as Scotty, but unfortunately he’s not involved enough.

The baddies were a bit of a letdown. Nero is a bit too flat, and his ship is way too fancy, no matter where it comes from. Clearly some Hollywood junkie wanted a big, invulnerable dark ship to bring havoc in the galaxy, but that is NOT a Romulan ship, period.

At any rate, I enjoyed the movie and I’m looking forward to the second one, which I hope it will be followed by many others.

Unfortunately in Italy Star Trek is not worshiped in Italy as in it is the US, which is very unfortunate… Roxanne and I decided to play along and go to the cinema half-dressed-up, but our friends Elora and Michelle came with a full-blown Uhura uniform! The whole cinema kept staring at us. It was a bit freaky, but fun (check out the pics on Facebook—if you can, that is, I won’t post them here!).

Wedding Planning

Just over a month to my wedding. Scared? You bet. Stressed out? Indeed. Roxanne and I managed to get most of the things organized in the end, luckily. In particular, this month:

We went to the British Consulate in Milan, and applied to get Roxanne’s legal documents.
I bought and had the 7 vest sets delivered to Roxanne’s brother’s (Caspar) place, in London.
I ended up buying 8 (buy three, get one free) morning suits from Marks and Spencer, and had them delivered to Caspar’s place. He’ll be sending all the stuff over soon, hopefully.
Roxanne got the dresses for the maids of honor, and apparently we have to collect them on monday.
We sent all the invites we needed to send, but we’re still waiting for confirmations. It looks like it won’t be a big wedding, probably around to 60-70 people mark.
We ordered the bomboniere, they should come through soon.
Uncle John told us he had the music for the church and the reception sorted out.
We got the rings!

We still have to organize a few things, namely:

Write and print the prayer books
Book the flight for one of my ushers
Get some fancy gifts for the bestman and the rest of the people involved in the ceremony
Get married civilly here in Genoa
Organize a party at our place for the people who can’t come to the wedding
Do something else I can’t remember right now

Yes, we are still busy as hell. I’m looking forward to it all, but I’ll definitely be much more relaxed when it’s all over!

Home Internet: Epilogue?

I got broadband at home, finally, after five months. Let’s do a quick recap:

Last December I signed up to Libero Infostrada, and told them I wanted to disconnect from Telecom
In January I actually got disconnected from Telecom, got a new phone line contract, but the Internet was never activated.
I kept calling clueless operators on both ends pointlessly for 2-3 months.
I got pissed off with Libero, so in April I signed up to Tele2, telling them to disconnect me from Libero. They told me it would take at least 4 weeks.
Meanwhile, I signed up to 3g, and got an Internet USB key. At least I can go online, even if with a crappy UMTS connection.
After a month, Telecom rings me asking if I want to come back to them, promising I’ll have the Internet back on soon enough. Out of desperation, I accept and tell them to disconnect me from Tele2.

Just when I was about to write a long post cursing Telecom and their perverted schemes to force their customers to stay with them, I receive a call from Libero and they tell me that the Internet is now activated! Unbelievable. Now all I have to do is send letters to all the other ISPs (they don’t do these things on the phone—clueless operators, remember?) telling them I don’t want anything to do with them anymore.

This is how broadband Internet works in Italy. Jealous?

Nimrod

Last month I decided I would stop programming until after the wedding and so I did (at least at home). Nevertheless, I still keep strive to keep up-to-date with everything concerning technology and in particular programming.

Out of all the tech news I came across throughout this month, the Nimrod programming language definitely struck me the most. A German guy came up with a new language—that’s not a big news, new programming languages are born every week, if not every day.

I believe Nimrod is different though. Basically, here’s why:

It’s a mixture of Lisp, Python and C. It looks a bit like Python and it behaves like it (indentation matters), it allows the creation of macros, like in Lisp, and – this is what really matters to me – it compiles to plain C (which can then be compiled using GCC or whatever).
It is open source and can be used to produce commercially distributed executables.
The manual is simple to read (but with a few rough edges), and the language looks simple to learn.
The language is not yet complete, but it’s getting close to a 1.0 release. It works as advertised, nonetheless.
It offers a comprehensive standard library, and a huge amount of libraries and wrappers from everything from Windows API to GTK and Cairo.
It is cross platform, the Windows version even comes with a one-click installer.
It has garbage collection and it supports manual memory management, if you need it.
It’s statically typed, with type inference
It can generate standalone executables, with very little overhead (90KB for an hello world program).

A language like this has been my secret dream for a long time. I thought no one would ever come up like this. I am really looking forward to give it a proper try someday. What’s wrong with it? For now, a few bits are missing (like native serialization), other than that someone pointed out the weird, rather extreme case insensitiveness of the language. Basically, case and underscores are ignored to allow programmers to use their own programming conventions. Personally I don’t think this is that bad. After all, if you name your variables “a_thing” and “aThing” and you want them to mean different things, that’s bad programming style anyway. Nevertheless, as far as I know it’s the only language I know which offers such an extreme degree of flexibility in this sense.

Learning new things

This month I also found myself to be extremely eager to learn about new things. I’m still faithful to Ruby and all that, but I’m opening up to new possibility, for different things:

I decided to start listening to slightly more technical podcasts, which are _not_related to tech news. In this way, I don’t have the pressure of having to listen to them on a regular basis. Other than FLOSS Weekly, which is probably the best show about Open Source Software out there, I’m going to try out Software Engineering Radio and The Command Line, both slightly more technical.
Because I decided to put my personal programming projects on hold, I’m having all sort of new ideas about even more projects I could start as soon as I can. No anticipations until after my wedding, of course.
I’m using Vim all the time now, both at work and at home. I feel confident with it, but I feel I still have a lot to learn, especially when it comes to marks, registers, etc. And I’m not yet ready to write an article about it—not the kind of article I’d like to write, anyway.
I’d like to learn more about Javascript and JQuery. I played around with it and loved it, but I really never used it for anything serious yet. This, however, may change in the future.

Personal Log - April 2009

h3rald@h3rald.com (Fabio Cevasco) — Tue, 28 Apr 2009 06:11:00 -0000

April is tratidionally a rather busy month: Easter, public holidays, and — always — some deadline to meet at work. Moreover, my birthday is also in April which makes it even more busy! Let’s see what happened this year…

Using Ruby in a corporate environment

I’ve been using Ruby at work for a while now. I started off writing some automation script for my own needs, then someone noticed it and asked me if by chance I could develop some scripts for them, for automating part of their own job, and so on. My boss ultimately noticed it, and she liked the idea of me investing a small portion of my time to make other people save huge amount of their time, so now I am officially in charge of workflow improvements and automation (it’s even in my job description!).

This month a colleague of mine and I had to figure out a way to write some documents once in XML format and then produce different kind of outputs (other XML files, PDFs, etc.) using the DITA Open Toolkit. Originally we thought the toolkit would do most of the job, but we soon realized we needed to tweak and change a lot more than what we usually expected.

We ended up hacking together a system using:

Microsoft Infopath as XML editor for the end users (the company buys it by default, so no worries there)
A Ruby program to parse and manipulate the original XML and produce DITA-compatible XML files.
Some Apache Ant tasks available in the open toolkit to produce an XSL-FO file
Apache FOP to produce the PDF from the XSL-FO file…

The thing seems to work fine (after a lot of tweaking), and I really enjoyed creating the Ruby program to glue everything together. I even got a chance to introduce my colleagues to the wonderful world of Textile (they are so happy that they don’t want to use WYSIWYG editors anymore!).

Easter in London

As usual, Roxanne and I spent our Easter holidays in London, at her brother’s place. This year we actually had 9 days to go around ~~squandering money~~ spending wisely in food, books, clothes and entertainment.

Most notably, I managed to drag Roxanne to Foyles and I got myself a copy of The Pragmatic Programmer, which I’m reading avidly. If it was up to me I was going to buy half of the computing section, but Roxanne kindly pointed out that I could get all of them from Amazon for half the price. And she was right: for my birthday I preordered a copy of Programming Language Pragmatics, 3rd Ed., which should be shipped soon.

Wedding planning

My spreadsheets for the wedding guests, wedding expenses (!) and …suit sizes are getting bigger and bigger. We managed to book a lot of flights to Ireland to my parents, us, relatives etc., but there are still quite a few things to do for the wedding. The most urgent thing to do right now is sending the invites: we had them printed with the words RSVP within May on them, so they have to be out in one or two weeks at most.

The other thing which must be sorted soon are the suits. According to English (and Irish) tradition, the groom, the bestman, the father of the groom, the father of the bride and the ushers have to wear the same type of suit, with minor differences (the color of the waistcoats?). In my case, this means getting 7 (SEVEN) morning suits off eBay, in the right sizes! Hopefully I’ll be able to get them by the end of next week (if my bestman manages to let me know his sizes).

XBox 360 Gaming

Now that our new XBox 360 finally came through, Roxanne and I have a lot of hours of hard core week end gaming ahead of us! This, added to the physiological increase of stress due to the wedding, may result in a temporary slowdown of my coding and writing activities. Right now we’re playing Mirror’s Edge, Mass Effect, and Unreal Tournment III. The last one was a special surprise present from Roxanne (”…so we can kill each other!” — she’s really lovely at times!).

Other tech-related tidbits

I can’t wait to go to the cinema to watch Star Trek XI
I started using Shelfari
I started using Star.io as my personal, bare-bones start page.
I recently released Concatenative 0.2.0.
I’m currently evaluating the possibility to create a Ruby-based Document Authoring Framework. Stay tuned.

Holiday house for rent

h3rald@h3rald.com (Fabio Cevasco) — Fri, 24 Apr 2009 01:54:00 -0000

Part of my family house in the countryside is now available for rent! It’s located in the small village of Sessarego, a few minutes away from the coast, on the Italian Riviera. We’ve been living there recently for 6 months when I started working and then moved to the city in order to be nearer to my workplace, but we still go there on holidays or on the odd week end, sometimes.

The house is fully furnished, it has been recently renovated, and offers all major comforts and services (utilities, TV, internet, phone, etc.). It can be ideal as a holiday house for writers, programmers, or anyone who would like to take a break from the chaotic city life without giving up all the commodities of modern life, such as the Internet.

For more information, see this page and feel free to contact me if you want to book your stay or you needmore details!

Concatenative 0.2.0 released

h3rald@h3rald.com (Fabio Cevasco) — Sun, 19 Apr 2009 09:42:00 -0000

Version 0.2.0. of the Concatenative DSL has been released.

Here are some highlights from the changelog:

Implemented new combinators:
- binrec
- split
- twodip
- threedip
Performance improvements:
- Stack is never copied.
- No symbol/string conversion when processing words.
Pseudo-namespace support (e.g. :kernel/:while and :math/:factorial)
~ and <= operators to unquote and define words, respectively.
No more uppercase words!

Oddly enough, I realized that it is possible to defined methods named after reserved words like “while” or “if”, so now all the concatenative words (combinators) in kernel.rb are now defined without a leading undersore. Similarly, there’s no real need to use UPPERCASE symbols, so as a result, method lookup is significantly faster and will use less resources.

Here’s how the lookup works. Say you have the following program:

[[1,2,3], [4.5.6], :concat]

If :concat has been defined by the user (:concat <= [...]), that definition will be used, otherwise the Concatenative::Kernel combinator concat will be called. If you want to use the corresponding Ruby method, all you have to do is specifying the arity explicitly using the | operator.

To remove any ambiguity, it is now possible to specify the namespace of a word explicitly, e.g. :kernel/:concat or :ruby/concat. The / operator simply concatenates the two symbols together (:"kernel/concat") and sets the namespace (:kernel) and name (:concat) of the new symbol. :kernel and :ruby are not meant to be used when defining new words, but you can use anything else you like, for example :math/:factorial or :local/:a, etc.

As I pointed out in the first article about concatenative, even with the new performance improvement a concatenative program still runs slower than a standard Ruby program, but at least now you won’t run out of stack space (the Ruby stack, in this case) too soon.

If you have any issues to report, feature requests, etc., feel free to use GitHub to do so.

Personal Log - March 2009

h3rald@h3rald.com (Fabio Cevasco) — Mon, 30 Mar 2009 06:04:00 -0000

Another month without the Internet at home. This is getting really annoying, and I decided to change provider, again, hoping that I’ll eventually get my broadband back, someday. Luckily I can still go online at work, but of course it’s not the same thing: my time on Twitter and Facebook is now basically limited to weekends only, when Roxanne and I go down to Tuscany to stay with her parents.

Concatenative programming

For some weird reason I became fond of the Concatenative programming paradigm. I started reading about Joy and then started to work on a Ruby DSL able to do the similar things: Concatenative. Another pet project — as if I didn’t have enough things to do already!

Some people seemed pleased about it, especially on Reddit and dzone. The downside of it is that it’s still fairly slow if compared to Ruby code (which is not exactly fast, either!), so if I had some spare time I should really try to implement it as a C extension, maybe.

Learning new programming languages?

Incidentally, I’m still fighting with myself on whether to learn another programming language or not. At this point, learning Factor could turn out to be more natural than months ago. However, I would only learn new programming languages as a hobby, as I don’t need to do so for profit: luckily I’m still a happy technical writer and I enjoy my job.

I admit, I’m still looking for the perfect programming language which is fun to learn (not easy: fun), elegant, minimalist, fast, general purpose and cross platform (meaning Linux, Windows, and Windows Mobile as well). Of course there is no such thing out there and there will never be, so I’m still evaluating the current alternatives. Possible candidates are Haskell, Factor, some dialect of Lisp or C. Why C? Well, because I didn’t do much with it since my first year at uni, and it could still be useful to write Ruby extensions or implement something at a lower level. After so much time getting spoiled by high level languages, I kinda miss the low level stuff. Ahhh where are all the pointers gone?!

On the other hand, I’m getting married soon, and I should use these months to help my wife-to-be a bit more with wedding planning (see next section). After all, I can always learn a new programming language after getting married, right? …right?!

Wedding planning

Roxanne and I are slowly getting more and more things done for the wedding. Every attempt I made to introduce her to GTD failed miserably so far, or better, it worked too well: she is now getting used to make lists and deciding on our next actions for the weekend. This weekend we booked our flights to Ireland, looked at cottages and hotels for the three days after the wedding (not the honeymoon yet, we’ll have a late honeymoon in autumn), chose the waistcoats for me, my bestman and the ushers, and …booked the wedding car! Now, this turned out to be good fun! Take a look at Ruby (yes, yes, I know… ), a Silver Cloud II 1961 Rolls Royce which will be ours for (less than) one day!

Other tech-related tidbits

I successfully migrated to Ubuntu 9.0.4 Jaunty. Everything works, except the flash plugin for Firefox.
I’m now using TweetDeck as my main Twitter client on both Windows and Linux.
I’m thinking of buying (after the wedding) an Eee PC (no Macs: Ubuntu is sleek and powerful enough &emdash;and free, too).
We finally got an XBox 360 from eBay, this time it came through the post.
Roxanne is thinking of buying a big LCD TV to go with it &emdash; I’m politely (and sadly) postponing till after the wedding.
After listening a FLOSS Weekly episode featuring it, I think I’ll get myself an Arduino Board for my birthday.

Concatenative programming in Ruby

h3rald@h3rald.com (Fabio Cevasco) — Sat, 28 Mar 2009 07:24:00 -0000

A while ago, I sat down examining a few alternative programming languages I might decide to learn someday. Each of those languages has its own peculiarities, and I didn’t choose them randomly, I chose them based on their popularity, power, paradigm and how actively they are developed.

I included Factor as the only representative for concatenative programming, an interesting way to write programs, but seldom used in “recent” languages (except for Factor and a few others).

The Joy of concatenative programming

If you have absolutely no clue on what I’m talking about, you should consider looking at the home page for the Joy Programming Language, or maybe just the overview: it should be enough to tikle your curiosity.

Joy is often considered the canonical concatenative programming language: a basic —but working— implementation of a simple programming language to illustrate the fundamentals of concatenative programming. Joy looks like this:

2 3 + dup *

This simple programs computes the sum of 2 and 3, pushes it on the stack, duplicates it (using the dup combinator) and then multiplies the two values, obtaining 25 as a result.

Let’s slow down a second. Here’s what happens, exactly:

Element entered	Stack contents
2	[2]
3	[2 3]
+	[5]
dup	[5 5]
*	[25]

Got it? Let’s take it one step further. When you enter dup and then *, you are effectively computing the square of a number, so we can define the function square simply as:

square == dup *

In Ruby, this would be:

def square(x)
  x*x
end

What’s unusual here? — Simple, there are no variables involved. Joy doesn’t need any explicit variable or formal parameters of any sort.

There’s more. Take the following code:

[1 2 3 4] [dup *] map

The map combinator expects a list and a quoted program (the same one used to compute the square) and produces a new list containing the result of that program applied to each element of the original list. Basically the equivalent of:

[1,2,3,4].map { |e| e*e }

Do you notice anything different? — Yes, Joy doesn’t need blocks or lambdas either, it uses quoted programs instead, which are nothing but slightly fancier lists (or arrays, as you like).

Let’s recap then, Joy doesn’t need of:

lambda functions or blocks (quotation does the trick)
explicit parameters (everything you need is on the stack)
variable assignments (same as above)
explicit recursion (provided you can use combinators like linrec, primrec, binrec, etc.)

I would consider this one of the best examples of programming minimalism: an incredibly simple syntax, a very small set of rules, but a good deal of power.

Ruby objects on the stack

After reading about Joy, I realized that implementing something similar in Ruby would be an interesting mini-project (let’s say a week of lunch breaks) to understand more about concatenative programming. It would also be pointless, too: a stack-based programming language implemented on top of one of the most high-level programming languages you can find isn’t going to be fast, is it? Nevertheless, it would still be interesting.

Ruby offers everything you need to build a Joy-like DSL:

You can use arrays as …arrays, but also as quoted programs, and to model the stack itself.
You can use integers, strings, etc. as themselves
You can use Symbols as functions (we’ll get to this in a minute)

If you think about the following expression in postfix notation:

2 2 +

We could translate it into infix notation (2 + 2), because Ruby supports it, but it’s not general enough. What you could do is this though:

2.send(:+, 2)

Message sending. I can see all the SmallTalk sympathizers drooling already. Well yes, In Ruby, everything is an object, so everything has a receiver and maybe some parameters. In other words, every method call can be reduced to the following syntax:

receiver.send(method, *params)

In this way, it is safe to assume that everything has a receiver, which could be understood as a function parameter, and may have 0 or more parameters. Take the following then:

[2, 2, :+]

It’s not too different from Joy, and it’s still Ruby code. All you have to do is use something to do the following:

Take an array, and examine each item:
- If it’s an object (non-Symbol), then push it on top of the stack.
- If it’s a Symbol, then do something different, i.e.:
  - Find its receiver and its parameters and call a method.
  - Manipulate something on the stack.

In this case, we have to find :+’s receiver and its parameter and we’re sorted.

Unfortunately Ruby’s arity method isn’t that reliable. For example: "test".instance_method(:sub).arity returns -1, while it should return “2” to be useful. So we have no choice but find a way to pass the method’s arity explicitly, in some cases.

For example like this:

["Ciao, Fabio", /Ciao/, "Hello", :sub|2]

If we define a | operator for the Symbol class, it’s not too bad after all. It’s heavy, but in this way we can use any Ruby method in postfix notation.

Introducing the Concatenative Ruby DSL

Concatenative is a simple Ruby DSL for concatenative programming. You can write concatenative programs inside ordinary Ruby arrays and execute them by calling either Array#execute or Kernel#concatenate, like this:

require 'concatenative'

concatenate(
  10,
  [0, :==],
  [1, :+],
  [:dup, 1, :-],
  [:*],
  :linrec
 )

This simple program calculates the factorial of 10. As you can see, no matter how unusual it may look, it is perfectly valid Ruby code and it is equivalent to the following Joy code:


10 [0 =] [1 +] [dup 1 -] [*] linrec

Granted, Joy looks better, but that’s the tradeoff for not writing a parser for Joy syntax, after all. Looking at the code above, there are a few things to keep in mind when programming with Concatenative:

You are using Ruby arrays, so you have to use commas, at least
functions, operators and combinators (let’s just call them words) are available as Ruby symbols
The arity of all Ruby infix operators has been already set to “1” by concatenative using the set_arity method (which simply stores the arity of a particular symbol in a constant hash)
You can specify explicit arities using the | operator (:gsub|2, or :join|1)
Unless the arity has been specified, an arity of 0 is assumed.
You can define your own concatenative functions using the Symbol#<= method, which expects a quoted concatenative program.

Performance issues

In its current form, Concatenative can be very slow, as show the “benchmarks” provided in the /examples folder, especially if you use recursive combinators. This is understandable because everything is implemented in pure Ruby, which is totally unsuitable for low level stuff.

If you are interested, you are more than welcome to submit patches and suggestions to improve Concatenative’s performance, or, if you feel brave enough, you could help me create a C extension instead: things would become much faster then.

At any rate, feel free to play with it. You can get the source from GitHub, you can get the gem from RubyForge and you can submit ticket through GitHub as well.

Real-world Rawline usage

h3rald@h3rald.com (Fabio Cevasco) — Sat, 07 Mar 2009 04:54:00 -0000

So I finally decided to update RawLine last week, and I added a more Readline-like API. When I first started the project, I was determined not to do that, because the current Readline wrapper shipped with Ruby is not very Ruby-ish: it’s a wrapper, after all!

The good thing of having a new API compatible with Readline is that now people can use RawLine in their Readline-powered scripts, with very minor modifications.

Let’s have a look at some examples (they are also shipped with Rawline v0.3.1):

Rush

Rush is an excellent gem which provides a cross-platform shell environment, entirely written in Ruby. Being a shell, it obviously uses Readline for tab completion, and that does the job on Linux. On Windows though, things aren’t that easy:

text gets garbled if you write long lines
you can’t type certain characters if they use some key modifiers like , etc.

RawLine doesn’t have these problems (that’s the very reason why I created it), so here’s a simple script which launches a Rawline-enabled Rush shell:

require 'rubygems'
require 'rush'
require 'rawline'

class RawlineRush < Rush::Shell

    def initialize
        Rawline.basic_word_break_characters = "" 
        Rawline.completion_proc = completion_proc
        super
    end

    def run
        loop do
            cmd = Rawline.readline('rawline_rush> ')
            finish if cmd.nil? or cmd == 'exit'
            next if cmd == ""
            Rawline::HISTORY.push(cmd)
            execute(cmd)
        end
    end
end

shell = RawlineRush.new.run

What happens here? Nothing much really, all I had to do was:

Derive a new class from Rush::Shell
Set Rawline.basic_word_break_characters to the same value used in the original Rush code
Set Rawline.completion_proc to the same completion Proc used in the original Rush code
Rewrite the original run replacing Readline with Rawline

And it works as it was intended to, i.e. typing root['b<TAB> will expand to root['bin/, etc. Note that I didn’t write the completion Proc from scratch: it was already there.

IRB

After trying out Rush, the next logical step was trying IRB itself: I could never use it properly on Windows, and that was really frustrating. After a few minutes trying to figure out how to start IRB programmatically, I quickly came up with a similar example:

require 'irb'
require 'irb/completion'
require 'rubygems'
require 'rawline'

Rawline.basic_word_break_characters= " \t\n\"\\'`><;|&{(" 
Rawline.completion_append_character = nil
Rawline.completion_proc = IRB::InputCompletor::CompletionProc

class RawlineInputMethod < IRB::ReadlineInputMethod
    include Rawline
    def gets
        if l = readline(@prompt, false)
            HISTORY.push(l) if !l.empty?
            @line[@line_no += 1] = l + "\n"
        else
            @eof = true
            l
        end
    end
end

module IRB
    @CONF[:SCRIPT] = RawlineInputMethod.new
end
IRB.start

In this case, Rawline is included in the RawlineInputMethod class, derived from the original ReadlineInputMethod class, i.e. the class IRB uses to define (guess…) how to input characters. Again, all I had to do was set a few Rawline variables to match the ones used in Readline, and then redefine the function used to get characters. All done.

It works as expected (only with inline completion, of course): typing "test".ma<TAB> will give you "test".map, "test".match, etc.

You also get all Rawline key mappings for free (CTRL-K to clear the line, CTRL-U and CTRL-R to undo and redo, etc.), and you can define your own.

RawLine 0.3.0 released — now with Readline emulation

h3rald@h3rald.com (Fabio Cevasco) — Sun, 01 Mar 2009 07:47:00 -0000

RawLine 0.3.0 has been released. This new milestones fixes some minor bugs and adds some new functionalities, must notably:

Ruby 1.9 support
A filename completion function
A new API very similar to the one exposed by the Ruby wrapper for GNU Readline

Some of you asked for Readline compatibility/emulation and that was actually not too difficult to implement: all the bricks were already there, I just had to put them together in the right place.

The RawLine module (you can spell it “Rawline” as well, if you wish) now behaves like Readline. This means that you can now use RawLine like this (taken from examples/readline_emulation.rb):

include Rawline

puts "*** Readline Emulation Test Shell ***"
puts " * Press CTRL+X to exit"
puts " * Press <TAB> for file completion"

Rawline.editor.bind(:ctrl_x) { puts; puts "Exiting..."; exit }

Dir.chdir '..'

loop do
    puts "You typed: [#{readline("=> ", true).chomp!}]"
end

Basically you get a readline method, a HISTORY constant like the one exposed by Readline (Rawline’s is a RawLine::HistoryBuffer object though — much more manageable), and a FILENAME_COMPLETION_PROC constant, which provides basic filename completion. Here it is:

    def filename_completion_proc
            lambda do |word|
                dirs = @line.text.split('/')
                    path = @line.text.match(/^\/|[a-zA-Z]:\//) ? "/" : Dir.pwd+"/"
                if dirs.length == 0 then # starting directory
                    dir = path
                else
                    dirs.delete(dirs.last) unless File.directory?(path+dirs.join('/'))
                    dir = path+dirs.join('/')
                end
                Dir.entries(dir).select { |e| (e =~ /^\./ && @match_hidden_files && word == '') || (e =~ /^#{word}/ && e !~ /^\./) }
            end
        end

You can find this function as part of the RawLine::Editor class. The result is not exactly the same Readline, because completion matches are not displayed underneath the line but inline and can be cycled through — which is one of Readline’s completion modes anyway.

A few methods of the RawLine::Editor class can now be accessed directly from the RawLine module, like with Readline:

Rawline.completion_proc — the Proc object used for TAB completion (defaults to FILENAME_COMPLETION_PROC).
Rawline.completion_matches — an array of completion matches.
Rawline.completion_append_char — a character to append after a successful completion.
Rawline.basic_word_break_characters — a String listing all the characters used as word separators.
Rawline.completer_word_break_characters — same as above.
Rawline.library_version — the current version of the Rawline library.
Rawline.clear_history — to clear the current history.
Rawline.match_hidden_files — whether FILENAME_COMPLETION_PROC matches hidden files and folders or not.

I bet you didn’t know these methods were even in the Readline wrapper, did you? Probably because of lack of documentation. Anyhow, another very important difference beween Rawline and Readline is Rawline.editor, i.e. the default instance of RawLine::Editor used by the Rawline module itself.

This makes things easier if you want more control over the line which is being edited and the previously-edited lines. Sure, Readline#completion_proc exposes the current word being typed before hitting tab, and so does Rawline#completion_proc the difference is that if you access Rawline.editor.line you get a RawLine::Line object with all the information you could possibly need about the current line: the position of the cursor, the text, the order the characters were entered, etc. etc. Now you can imagine why it took me a few minutes to write the filename_completion_proc method (and why it will take you even less time to write your own similar method if you wanna do something different): you can access not only the last word being typed but also the current and previous lines (through Rawline.editor.history or just Rawline::HISTORY)!

It must be said, as usual, that Rawline is not a complete replacement for the Readline library yet (and it will probably never be, as Readline is huge!), but it’s a good cross-platform, more Ruby-esque alternative to what’s currently available by the Readline wrapper for Ruby.

It’s not as fast, of course, especially when completing long words, but it’s quite usable. The following libraries are not required but recommended:

win32console (on Windows)
termios (on *nix)

They basically make Rawline faster. If you don’t use them, Rawline will fall back on its pure-Ruby implementation to move left and right (i.e. printing backspaces and spaces character codes instead of ASCII escape codes).

Unfortunately, there’s no vi_editing_mode or emacs_editing_mode yet (for time constraints: they can be implemented!) but patches are very welcome. Also, if you need more features, all you have to do is ask :-)

P.S.: Check out the new Project Page and especially its Resources section!