Vinum Regum, Rex Vinorum

Louis XIV

A few years ago I had the good fortune to spend a 10 days in Budapest. While there I developed a taste for Hungarian wine, especially Egri Bikáver, and Tokaji, the wine that Louis XIV loved so much. These wines used to be very difficult to come by in Ireland. Fortunately, this is no longer the case, as a wine shop specializing in Hungarian wines has opened in Dublin. The shop is called Essence of Wine and is located in the Moore Street Mall. The staff there are passionate about wine, very knowledgeable and helpful. I was there a few weekends ago I spent about half an hour chatting about wine and Budapest with Laszlo, one of the guys that runs the place. Over the course of the conversation he recommended 2 wines from the Gal Tibor winery, which I bought, and which were shared with friends last night. They were superb. So if you happen to be shopping in Dublin for a good bottle of wine, I'd recommend there.

Technorati Tags: wine Hungary

• HelloSablecc
• HelloAntlr
• FlexibleAntlrGeneration
• HelloCup
• HelloRacc

Technorati Tags: programming antlr sablecc parsers racc cup

ANTLR is a parser generator tool that is capable of targeting multiple output languages. Out of the box, it will generate Java, Python, C, C#, or Ruby code. Other target languages are possible if the code generators are written. Amongst its cool features are:

• LL(*) parsing: This is an extension to the normal, top down with lookahead, LL(k) parsing technique. It allows for more powerful parsers than those possible with LL(k). Not something I have needed yet, but I can see it being useful in the future.

• Semantic and syntactic predicates: These are tests that can be embedded in grammar rules to turn certain choices in rules on and off based on a boolean test. These allow parsers to be built that simulate recognizers for context dependent grammars and this makes the automated parser generation applicable to a lot more problems. Again, this is something I haven't used yet, but will be in the future.

• Memoized backtracking: This is a performance improving feature for grammars that use a lot of lookahead. If a parser fails at a choice near the end of the rule it has to go back to the start of the rule and start matching again. The memoization of intermediate matches for a rule speeds this up.

• Unicode support: parsers built with ANTLR recognize Unicode input. ANTLR grammar files themselves do not recognize Unicode characters yet, but Unicode characters can be specified as escape sequences.

• Hierarchical lexers: Most parser generator tools define tokens by means of a regular expression like language. For these tools lexer rules are independent of each other and cannot refer to each other. ANTLR is different: it allows lexer rules to reference other lexer sub-rules. It also allows recursive lexer rules. Now, this is a very useful feature and, for me, tidies up lexer rules a lot.

• Abstract Syntax Tree (AST) generation features: ANTLR has a powerful AST generation feature. When generating parsers I prefer to generate a parse tree or AST and pass that onto a second stage, rather than embedding actions/code in the grammar. This allows the a parser to be used as a module in numerous tools. ANTLR's AST building support is superb and really facilitates that type of design.

• Tree grammars: This is a feature of ANTLR that allows for a parser to match tree structures such as ASTs and trigger an action based on this. I used to use JavaCC and what I normally did was use it to generate a parse tree and then use the visitor pattern to process that parse tree. If the action at a particular node depended on the structure of the tree, it was up to me to track that in the Java code in the visitor class. ANTLR's tree grammars really simplify situations like that and I am really looking forward to trying that out.

The Definitive ANTLR Guide, available from the Pragmatic Programmer website, is the main documentation for ANTLR v3.0. The book is well named. It clearly and concisely describes the features of ANTLR v3.0 and how to use them. The book is divided into 3 sections: an introduction to ANTLR and language translation, a reference section for the ANTLR syntax, and a section on how to write predicated LL(*) grammars. I have read through the first section and skimmed parts of the reference and this has enabled me to put together a basic parser/recognizer for Scheme. It really is that straight forward.

In addition to The Definitive ANTLR Guide there is a really good Wiki with tutorials and FAQs at http://www.antlr.org/wiki/display/ANTLR3/ANTLR+3+Wiki+Home. Lastly, the distribution comes with great sample grammars. There is a Java grammar and a Python grammar in there and these put ANTLR through its paces and are worth referring to.

ANTLRWorks is the IDE for building ANTLR grammars. It is a standalone editor, written in Java Swing, that provides the standard features that you would expect from an IDE, such as syntax highlighting and error detection. In addition it has a few handy features that you would not expect. Firstly, there is a syntax diagram pane in the GUI. Selecting a grammar rule in editor pane causes a syntax diagram for the rule to be displayed in the syntax diagram pane. The graphic below is an example.

This is very useful for documenting grammars as the diagrams can be saved as graphics (JPEG, PNG, EPS, etc.). There is also a debugger and an interpreter. The interpreter will interpret the grammar and draw a graphical representation of the parse tree for an input string based on the grammar. If the parse fails it still draws the diagram for what was recognized and puts a node in the tree, at the point were the parse failed, to represent the type of error detected. The parse tree graphics can also be saved and are a real help with visualizing how the rules fit together and what choices the parser is taking.

Technorati Tags: programming antlr

1. Be brave and aggressive.

   • Be direct.
   • Grab all opportunities.
   • Using varying methods of attack.
   • Be versatile and agile.
   • Attack one target at a time.
   • Don't plan everything in detail.
   • Use top quality weapons.

2. Be prepared.

   • Keep weapons in good condition.
   • Keep in shape.
   • Find good battle comrades.
   • Agree on important points.
   • Choose one chief.

3. Be a good merchant.

   • Find out what the market needs.
   • Don't make promises that you can't keep.
   • Don't demand overpayment.
   • Arrange things so that you can return.

4. Keep the camp in order.

   • Keep things tidy and organized.
   • Arrange enjoyable activities which strengthen the group.
   • Make sure everyone does useful work.
   • Consult all members of the group for advice.

These laws are pretty relevant to software development and the software business in general. In my experience, problems during software development projects stem from one of these guidelines not being followed. It is particularly dangerous to ignore Choose one chief, Find good battle comrades, or Don't make promises that you can't keep. Yet again, advice on software development has come from an apparently unrelated source.

A new draft of the R6RS for Scheme: Revision 5.92 Recommended Specification for Scheme is up on site, www.r6rs.org. It has been split into two PDFs, one for the core language and one for the libraries. The total page count for the two files is about 150 pages.

The positives are:

• The language is terse. There is very little boiler plate code needed to get up and running in Fortress. Hello world is:

  export Executable
  run(args:String...) = print "Hello, World!\n"

• Fortress is designed to have a syntax that resembles mathematical notation. For example, the absolute value function appears like this in Fortress: |someVar|. This makes the code really brief and also partly familiar to mathematically inclined readers. Fortress is a good way along to achieving Fortran's original goal of formula translation.

• Operators are functions and can be defined for classes, overloaded, etc. In addition to normal operators, it is possible to define bracket operators, e.g., the absolute value operator shown above.

• Multi-paradigm programming is supported, particularly for OO and functional styles.

• There is strong support for parallel/multi-processor computing. I have not played with this, but the demos include a parallel matrix multiplication example that demonstrates this.

• Fortress has support for comprehensions, similar to those in Python.

The negatives are:

• The language is not fully implemented yet, so some features are not working, e.g., atomic modification of multiple variables is not fully implemented yet.

• Libraries are extremely sparse at the moment. There isn't even a maths library yet.

Other interesting things:

• Fortress targets the JVM initially. This means that there is a possibility of calling Fortress programs from Java programs via the interfaces defined by JSR 223.

• Fortress makes extensive use of Unicode and this use isn't superficial: many of the mathematical operators and functions can be specified by the Unicode characters used to display them in mathematical papers. For example, the floor function on a variable x can be written as ⎣x⎦ . In fact the Fortress compiler and interpreter deal exclusively with Unicode. While Fortress programs can be written completely in ASCII there is a conversion stage that translates ASCII longhand into equivalent Unicode characters before the lexer and parser get at the code.

The staff there are pretty cool and know their stuff, so I am learning lots. A few of them have blogs, notably (in alphabetical order), Bill de hÓra, Vicky Lee, and Sean McGrath. Anyhow, so far so good. I need to check with people here what is considered proprietary information, but hopefully I will be able to blog about some of the things I have learned over the past few week.

I have been meaning to attend a Python Ireland meeting for quite a while. Last Wednesday I finally got around to it and I was treated to two excellent talks. The first was by Sean McGrath on Jython. This gave an introduction to Jython, with some examples of where it could be useful in a Java environment. The SWT GUI example was particularly good in showing how Jython could compact GUI code for Java applications. Sean also filled in a lot of background around Python on the JVM and Microsoft's CLR and this lead to a lively discussion.

Mick Twomey gave the second talk, briefly, as the Jython discussions took up most of the session, and described the Web Server Gateway Interface (WSGI). This is a rather clever API, developed to modularize Python web frameworks. It essentially applies the decorator pattern to code running in the web framework. For example, if you have a web application that you want to have protected with a password, you could use an authentication module with the WSGI to add that to your application. In a sense, the authentication module is applied as a decorator for the application code. Mick also gave an example of gzip compression. WSGI sounds pretty useful.

After the talks the attendees took a short walk to The Pembroke for a beer and more conversation. This could become a regular occurrence for me.

Firstly, a cousin of mine, who was a year younger than me, died of cancer. That was a shock and really brought home the preciousness of time. I have spent a lot of time reflecting on life since.

Secondly, to use the HR terminology, I was impacted in a reduction of force in SUN, i.e., I was laid off at the start of October. I have spent most of the time since then getting my CV in order and searching for jobs. I have some interviews coming up and the market looks reasonably buoyant, so I am not too worried. I am still looking, however, and any pointers to interesting jobs in Ireland, the UK, or mainland Europe would be appreciated.

Lastly, on a pleasant note, I am just back from a holiday in Iceland. I really enjoyed that and it will be the topic of a later blog posting.

Anyhow, this is about as close to a meta-blogging post as I want to get. I will end it with an apology for the hiatus and a promise to post more regularly.