David J. Pearce (Blog)

Fall-Through by Default for Switch Statements?

Wednesday, October 26th, 2011

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.

What Kind of Revert are You?

Wednesday, October 19th, 2011

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.

Namespaces in Whiley

Saturday, September 3rd, 2011

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 namespaces.

Simplification vs Minimisation of Types in Whiley

Tuesday, August 30th, 2011

Recently, I’ve been trying to harden up the implementation of Whiley’s type system. The reason for this is fairly straightforward: bugs in the code often prevent me from compiling correct programs!

A Subtyping Gotcha

Monday, August 29th, 2011

An interesting issue with the following piece of code has recently come to my attention: define Queue as process { [int] items } int Queue::get(): item = this.items[0] this.items = this.

Parallel Sum in Whiley

Wednesday, August 3rd, 2011

Recently, I’ve been working on a variety of sequential and concurrent micro benchmarks for testing Whiley’s performance. An interesting and relatively simple example, is the parallel sum. The idea is to sum a large list of integers whilst performing as much work as possible in parallel.

A Semantic Interpretation of Types in Whiley

Friday, July 29th, 2011

An interesting and intuitive way of thinking about a type system is using a semantic interpretation. Typically, a set-theoretic model is used where a type T is a subtype of S iff every element in the set described by T is in the set described by S.

Implicit Coercions in Whiley

Thursday, July 21st, 2011

The issue of implicit coercions in Whiley is proving to be a particularly thorny issue. The following motivates why (I think) coercions make sense: real f(int x, real y): return x + y real g(int x, int y): return f(x,y) I believe the above should compile without error.

Compile-time Verification, It's Not Just for Type Safety Any More

Tuesday, July 12th, 2011

I just came across an interesting presentation over at InfoQ called “Compile-time Verification, It’s Not Just for Type Safety Any More”: The talk is by Greg Young and focuses on .

Regular Tree Automata

Wednesday, July 6th, 2011

In my quest to understand the theory of recursive types in more detail, the notion of regular tree languages and Tree Automata has cropped up. These have been used, amongst other things, for describing XML schemas.