CHILL/2

CHILL (the CCITT High Level Language) is a strongly typed, block-structured programming language with built-in concurrency. It was designed by the international telephone standards body to program the computers inside telephone exchanges. The CCITT approved it as Recommendation Z.200 in November 1980, within weeks of Ada’s first military standard (MIL-STD-1815, December 1980) and three years before Ada’s ANSI standard, and it is of a similar size and ambition. By 1990 it was running some of the world’s largest switching systems, including Siemens EWSD, Alcatel System 12 and E10, and Japan’s D70. Few programmers outside telecommunications have heard of it.

This encyclopedia lists the language as CHILL/2. That name comes from the 99 Bottles of Beer collection (entry #126, dated 20 April 2005, anonymous author), whose example begins: “The CHILL/2 compiler I use has no VARYING strings.” No CCITT or ITU document, compiler vendor or history of CHILL consulted for this page uses the name “CHILL/2”, and which compiler the author meant is not known. The page therefore describes the standard language, CHILL as defined by Z.200. The program in that entry is ordinary CHILL.

History & Origins

A standards body designs a language

The telephone network automated early. By the late 1960s exchanges were becoming stored-program control (SPC) systems, which are special-purpose computers running very large real-time programs. Kristen Rekdal’s 1993 survey of the language reports that the groundwork began in 1966. The 1968 CCITT Plenary Assembly in Mar del Plata, Argentina, then decided that the CCITT itself should handle the work.

The CCITT concluded that switching needed three standard languages, not one:

• a specification and description language, which became SDL (Z.100)
• a high-level programming language, which became CHILL (Z.200)
• a man-machine command language, which became MML (Z.300)

In 1973 the CCITT evaluated 27 existing languages and shortlisted six:

It concluded that none of them was satisfactory. In 1975 an eight-person “Team of Specialists” was formed. Its members came from Philips, NTT, the Nordic telecom administrations, Siemens, Ellemtel, ITT, British Telecom and the Swiss PTT. The team had a preliminary proposal ready in 1976 and named it CHILL.

For the 1977-80 study period the team was replaced by the Implementors Forum. Its job was to encourage trial implementations and feed their experience back into the design. A completed proposal was ready by the end of 1979, and the CCITT Plenary Assembly approved it in November 1980 as Recommendation Z.200. Gard Paulsen’s 2011 doctoral thesis on CHILL’s history describes almost six years of negotiation between computer scientists, telecom engineers and officials from many organisations and countries before the language was released.

Compilers everywhere, mostly in-house

Rekdal reports that from 1977 “many companies and organisations” built CHILL compilers, and that more than 30 existed for many different computers by 1987. Most of the big switching systems were built with compilers their manufacturers developed in-house.

The best-documented independent compiler is the Nordic CHIPSY (CHILL Integrated Programming System). The telecom administrations of Denmark, Finland, Norway and Sweden, later joined by British Telecom, sponsored it at SINTEF in Trondheim from early 1977. It was first hosted on the Norsk Data ND-100 minicomputer and targeted the Intel 8086 and later the 80286. In 1984 it was spun off into KVATRO A/S. In Denmark, Dansk Datamatik Center reportedly also developed a CHILL compiler (this is not in Rekdal’s paper and was not independently verified).

Design Philosophy

Rekdal’s paper gives three reasons why the CCITT built “yet another programming language” rather than adopting one:

1. To fix weaknesses in existing languages when they were used for telecom systems, which have special needs.
2. To consolidate in one language features that were otherwise spread across several.
3. To provide one standard shared by every manufacturer and operator of computerised telecom systems worldwide.

The target domain drove the design. Rekdal lists what makes telecom software unusual: real-time concurrent behaviour, programs of 100,000 to 10,000,000 lines, high reliability and availability requirements, lifetimes of 3 to 20 years, large and changing development teams, and many variants delivered across several hardware generations. CHILL responds with:

• Strong static typing with extensive consistency checking. Mistakes are caught by the compiler rather than in a live exchange.
• Concurrency in the language itself. Processes, signals, buffers, events and regions are part of the language, not a library.
• Modules with explicit import and export (SEIZE and GRANT), so that very large programs can be divided among teams.
• Machine independence, so that switching software could outlive the processors it first ran on.

The scope was deliberately limited: the CCITT’s remit, and so the language’s, was public telephone switching. CHILL is a general-purpose language nonetheless. The Jena CHILL homepage notes that several CHILL programming environments were themselves written in CHILL.

Key Features

Modes (types)

CHILL calls its types modes. The standard provides discrete modes (integers, booleans, characters, enumerated SETs and RANGEs), real modes, powersets, reference modes, composite modes (arrays, strings and structures, including variant structures), procedure modes, and modes for synchronisation, input/output and timing. NEWMODE creates a distinct type, and SYNMODE creates a synonym that is compatible with its base.

Concurrency built for switching

A CHILL program is a set of modules, conceptually enclosed in an outermost process. Processes are created with START and terminated with STOP. They communicate in three ways:

• Signals, sent with SEND … TO and received with RECEIVE CASE. These match the message-driven state machines that SDL diagrams describe.
• Buffers, bounded queues of values.
• Events, with DELAY and CONTINUE.

Regions give mutual exclusion: at most one process can be executing inside a region’s procedures at any time.

Exceptions and time supervision

A violated runtime condition raises an exception, which is handled by an ON … END handler attached to an action. Programs can raise their own exceptions with CAUSE. The 1988 edition added time values and timing operations, so a process can react when an external event does not arrive in time.

A small example

This is an illustrative sketch, not taken from any product. It shows the style of a signal-driven process modelled on the call-handling examples in the CHILL literature:

line_handler: MODULE
  SIGNAL off_hook, on_hook, dial = (INT);
  GRANT off_hook, on_hook, dial, line_process;

  line_process: PROCESS ();
    NEWMODE states = SET(idle, waiting, connected);
    DCL state states := idle,
        digits INT := 0,
        d INT;

    DO FOR EVER;
      RECEIVE CASE
        (off_hook):
          IF state = idle THEN state := waiting; digits := 0; FI;
        (dial IN d):
          IF state = waiting THEN
            digits +:= 1;
            IF digits = 7 THEN state := connected; FI;
          FI;
        (on_hook):
          state := idle;
      ESAC;
    OD;
  END line_process;
END line_handler;

Some syntax features are visible here. Blocks close with reversed keywords (FI, OD, ESAC), assignment is :=, and +:= is the compound form. DO FOR EVER is the standard idiom for a process that never terminates.

Evolution

The CCITT, renamed ITU-T in 1993, maintained CHILL through several study periods. Rekdal and the Jena CHILL homepage record the main additions:

ISO adopted the language as ISO/IEC 9496 in 1989. Later editions followed, and the fourth, ISO/IEC 9496:2003 (15 December 2003), carries the same title as the 1999 ITU text.

Before the standard added object orientation, Object CHILL had explored the idea. Jürgen F. H. Winkler and Georg Dießl presented it at a 1992 ACM conference in Kansas City. Winkler later wrote the tutorial overview of CHILL2000’s new features.

GNU CHILL

In August 1998 Cygnus Solutions donated a CHILL front end to GCC, written mainly by Per Bothner with Bill Cox, Wilfried Moser, Michael Tiemann and David Brolley. The announcement said that it mostly followed the 1988 language, with compatibility options for 1984, and “does not implement all of the features of any standard.” It called the release “an unsupported hacker release” for educational purposes, and said Cygnus maintained CHILL for a single customer. GCC 2.95.3 (March 2001) was the last GCC release to include it. The GCC 3.0 caveats list notes that the Chill compiler is not included. The encyclopedia lists GNU CHILL separately.

Current Relevance

Rekdal’s 1993 paper estimated that there were at least 12,000-15,000 CHILL programmers worldwide, and that more than 1,000 person-years had gone into CHILL compilers, tools and training. He also wrote that six of the ten largest telecom manufacturers (ranked by 1989 telecom turnover) used CHILL for their main switching products. His most-quoted figure concerns market share. Measured by the share of digital local lines installed per year in public exchanges, software written in CHILL supported about 45 % of the lines installed in 1990, up from 0 % in 1980. This figure is his estimate. It sums EWSD, E10, D70 and System 12, and ranks CHILL ahead of Northern Telecom’s Protel and AT&T’s C.

That peak did not last. Paulsen’s thesis is subtitled 1974-1999 and covers “the creation, use and ultimate demise” of the language. The 1999 edition was the last revision of Z.200, and GNU CHILL left GCC in 2001. The language’s lifespan follows the machines it was written for: exchanges built in CHILL stayed in service for decades and needed maintenance, but new telecom software moved to C, C++ and later Erlang and Java. Wikipedia describes CHILL as still used for legacy systems in some telecom companies and for signal-box (railway interlocking) programming. No figures were found for how much of that remains today, so that claim is repeated here without further verification.

No maintained open-source CHILL compiler or official container image is known. The GNU CHILL sources can still be found in GCC 2.95.x archives.

Why It Matters

CHILL is one of very few general-purpose programming languages designed by an intergovernmental standards committee for a single industry, and it achieved what it set out to do. Rekdal wrote in 1993 that it was the only programming language common to more than one of the major public switching systems. By Rekdal’s estimate, software written in it supported about 45 % of the digital local lines installed in 1990.

Several ideas that became common later were already in CHILL in 1980: processes and message passing built into the language, modules with explicit interfaces, and strong typing for very large, long-lived real-time systems. CHILL was also designed to work with SDL, so a specification drawn as communicating state machines could be translated almost directly into CHILL processes that exchange signals. According to Rekdal, the CHIPSY toolset completed an SDL-to-CHILL translator in 1992, and it could also interface to TeleLOGIC’s SDT tool.

Sources and Caveats

• Year. 1980 is the year the CCITT Plenary Assembly approved Z.200, in November 1980 (Rekdal 1993; the ITU-T Z.200 page lists editions only from 11/88). A preliminary language named CHILL existed from 1976, and trial compilers from 1977.
• “CHILL/2”. The only source found for this name is the anonymous 99 Bottles of Beer entry of 20 April 2005. It could be a particular vendor compiler, a second-generation dialect, or just the submitter’s label. That could not be determined.
• Influences. Wikipedia’s infobox lists COBOL, PL/I, Pascal and ALGOL 68 as influences but cites no source for them. The 1998 GCC announcement calls CHILL “a language in the Modula2 family”. Because none of these claims could be traced to the language’s designers, the influenced_by list above is left empty.
• Rekdal’s figures (programmer counts, the 45 % line share, 30+ compilers) come from Rekdal’s 1993 survey, which also promotes the CHIPSY toolset. They are presented here as his estimates, not independently verified.