Articles

Looking Forward to 2015

It’s scary to think that 2014 has been and gone, and that I still haven’t released the next major version of Whiley!  Despite this, I have been busy improving the compiler and language and I thought it would be helpful for me to recap what was achieved last year, and what the goals going . . . → Read More: Looking Forward to 2015

Proposed Syntax Changes for Whiley

Now that I’ve had the chance to write a reasonable amount of code in Whiley, it is time to reflect on some things I don’t like.  In particular, there are a number of issues with the syntax which I’d like to improve which I’ll document here.

Function & Method Declarations

Currently, the syntax for . . . → Read More: Proposed Syntax Changes for Whiley

The Architecture of Verification in Whiley

As the Whiley compiler continues to evolve, certain aspects of its architecture are really starting to mature.  One of the more recent pieces to take shape is the verification pipeline.  This is the process by which a Whiley file is converted into a series of verification conditions, which are then checked by the automated . . . → Read More: The Architecture of Verification in Whiley

The Liquid Metal Project

One of the most interesting projects I came across at PLDI/ECOOP in Beijing was the Liquid Metal project being developed at IBM’s TJ Watson Research Center. From the Liquid Metal homepage:

The Liquid Metal project at IBM aims to address the difficulties that programmers face today when developing applications for computers that feature programmable . . . → Read More: The Liquid Metal Project

Three Rules for Programming Language Syntax?

I’m always pondering the question: what makes good programming language syntax? One thing occuring to me is that many languages often ignore the [[Human-computer interaction|HCI]] aspect.  For me, it’s a given that the purpose of a programming language is to simplify the programmer’s life, not the other way around.

So, I thought of a . . . → Read More: Three Rules for Programming Language Syntax?

Fall-Through by Default for Switch Statements?

The switch statement has a long history, and most languages support it or something similar.  In my experience, I found it to be very useful — both for conciseness, and also improving performance.  With the recent release of Java 7, you can finally switch over strings.

In Whiley, the syntax for switch statements currently . . . → Read More: Fall-Through by Default for Switch Statements?

What Kind of Revert are You?

Reverting is tough.  There’s no doubt about it!  I don’t mean tough as in technically challenging — no, version control systems make this easy!  I mean tough as in mentally challenging.  You’re faced with days or weeks of effort going down the drain, and you have to decide when to pull the plug.  Sure, . . . → Read More: What Kind of Revert are You?

Namespaces in Whiley

With the upcoming v0.3.10 release of Whiley, the way import statements are interpreted has changed in a fairly significant manner.  The primary purpose of this is to give better support for [[Namespace (computer science)|namespaces]]. The following illustrates what’s changed:

import whiley.lang.Math bool check(int x, int y): return max(x,y) == x

Previously, the above code . . . → Read More: Namespaces in Whiley

Disambiguating Ambiguous Syntax?

When designing a programming language, being on the lookout for ambiguous syntax is important. You don’t want to realise down the track that your syntax is ambiguous in some subtle way. This is especially true if it means the compiler can’t decide how to proceed on some important case(s).  But, spotting these problems is . . . → Read More: Disambiguating Ambiguous Syntax?

Language Complexity?

Some languages are complex, others are simple … right?  C++ versus just about anything else is a good example here.  But, it begs the question: what makes a language complex?

So, I’ve just been reading Bruce Eckel’s Artima article on Scala.  It’s actually a nice article, and I enjoyed it.  But, one thing bugged . . . → Read More: Language Complexity?