A piece of intertube about the Clojure programming language, algorithms and Emacs.

Dear Language Designers, Do Not Forget Ada

May 8th, 2011

These last days I took some time to refresh my old memories of the Ada language. While Ada, like all languages, has defaults on its own I’m still very impressed by some functionalities it offers and that current mainstream languages still don’t have. Most of these functionalities are there since the first standardized version in 1983 (since then the language standard was extended in 1995, 2005 and the next version is expected for 2012).

The first impressive future is about primitive types. Here are some of the types defined in Ada and their C equivalent (taken from [1]):

Ada Type

Description

C Equivalent

Character

A single character

char

Integer

An integer (32-bit) number

int

Natural

Zero or positive integer

-

Positive

A positive integer

-

Long_Integer

A big integer (same as long in Gcc)

long (same as int in Gcc)

Long_Long_Integer

A really big (64-bit) integer

long long

Short_Integer

A small (16-bit) integer

short

Short_Short_Integer

A really small (8-bit) integer

char

Float

A real number

float

Long_Float

A big real number

double

Long_Long_Float

A really big real number

long double

Short_Float

A smaller real number

?

Fixed

A fixed-point real number

-

String

An Ada fixed-length string

char array

Boolean types are also provided. New types are defined and type safety is guaranteed. Here we define a new type based on a Long_Float and a variable of this type:

type Speed is new Long_Float;

Speedy_Gonzales_Speed : Speed;

Since Speed is a new type, it is not a Long_Float and thus assignment from a Long_Float value to a Speed variable is forbidden:

This allow a Degrees variable to range from -273.15 (absolute zero) to the last value allowed by a Float.

This strong typing provides safety and contrasts with what is seen in current mainstream programming languages. Languages like Java don’t provide rich primitive types (there are for instance no unsigned integer in Java!) and require the programmer to define its own cumbersome classes if he wants new types (which poses readability problems if the types are new number types and the language does not support operator overloading). Some languages like C don’t even bother so much about type conversion: a float can be assigned to an integer. This leads to solutions which are far from being satisfying (see for instance C FAQ - round).

A lot of other possibilities are offered to the Ada programmer, for instance decimal types can be defined with their precision. The precision is then guaranteed by the compiler:

At another level Scheme and Common Lisp supports a numeric towel. For example, 3 is an integer. Therefore 3 is also a rational, a real, and a complex (example from the Scheme standard).

;; in Scheme:> (rational? (/ 1 5))#t> (rational? 3)#t> (real? 3)#t

While this discussion may not make so much sense for dynamic languages such as Clojure, I think new languages being designed, which are not dynamically typed, could really benefit of having such rich primitives types. A complex type systems like the one from ML or Haskell is not needed for this purpose and primitives types is the most basic and most used feature of a programming language, so dear languages designers, next time, have a small thought for Ada.