Understanding the CESIL Programming Language
Introduction
Nowadays, many languages allow programmers to code apps, websites, thermostats, security programs, and even airplanes. However, it all started with low-level languages that require understanding how a computer works, where the programmer writes every little step.
CESIL is one of those low-level programming languages that use only integer operations and string output. The acronym stands for “Computer Education in Schools Instructional Language” and was designed to introduce the user to assembly language.
Cecil and CESIL can be easily mixed up. However, the language we are talking about should not be confused with Cecil, a language made in 1992 by Craig Chambers. Cecil was created for Cecil/Vortex research at the University of Washington.
Benefits and Downsides
The language is easy to understand and simple to write compared to modern-day languages. This, in turn, allows people to focus on what the code does when put through the computer. In the long term, the mindset learned is beneficial to learning how to program.
In addition, CESIL directly communicates with the hardware. This allows programmers to debug easier time since there is less interference with syntax or external devices. Direct communication also means that the processing times are fast. As hardware is only translating the CESIL code to binary, not much is interfering with the process.
However, with CESIL, the codes tend to be longer compared to newer languages. This is because newer languages often have code that has been derived from low-level language instances. With CESIL, it is more likely to start from scratch.
Similar to other low-level programming languages, CESIL is machine-dependent. Thus, it would require a solid base knowledge about how the target computer or machine operates. In addition, this means that CESIL is not portable as it is loyal to the processing system.
History
As programming education gained traction, in 1968, the ICL-CES Project was built. The purpose was to provide young people with more awareness in their lives around computers. The ICL-CES Project soon began producing programming materials and providing lesson support. See the picture on the right of a programming material that ICL-CES created. They also started teaching BASIC and later CESIL to secondary students. From 1968 to 1970, 30 schools in Britain adopted the curriculum, which impacted around 600 students.
CESIL was created in 1974. The purpose of CESIL was to give secondary school computer science students (‘O’ level) in Britain a simple computing language to learn. Running and debugging code during that time was more complicated than today since processing systems were rare. Often only teachers, universities, or more prominent organizations had access to resources that would allow for processing code.
Usage
CESIL dropped in popularity after being discarded from general programming education. CESIL is not in use today in schools or the programming world. However, the exact date of discontinuance is not known. The language was soon replaced by others that were more effective and higher leveled. Especially with the rise of personal computers coming after CESIL around the 1970s, writing code on paper had become unnecessary.
CESIL was often written on paper then run through a processing system by a professor or a nearby university to run the program. This process would either take days or weeks, and the code would be returned to the students. After being returned, the debugging process started, and once the students were done, the process of running the code would be repeated by the teacher.
Given that CESIL is solely designed to teach secondary students, the language is not used in the workforce. Competing languages in the 1970s workforce around the world were Pascal, C, and BASIC. BASIC was taught around the same time as CESIL gained reputation from personal computers while CESIL did not. Popular languages such as Python, JavaScript have become leaders.
Arguments
Some former CESIL students argue that CESIL was neither a real assembly language. Nor did the language set the user up for complex high-level language constructs. However, others reminisce back to CESIL as their first known coding language. They argue that CESIL was an excellent language to introduce them to coding. They claim they learned concepts of assemblers, variables, data, decisions, and loops from CESIL.
CESIL was beneficial to students, for example:
Body
CESIL is an assembly language. Assembly language is a low-level language that uses machine instructions and an assembler to output a language. This means for CESIL to run, an assembler is needed as well as machine instructions. See the picture above of the system between high-level languages and hardware — assembly lines between high-level and machine code as a low-level language.
Assemblers are programs that translate written programs into binary code for the computer to understand the action needed. When writing low-level languages, it is beneficial to use an assembler instead of a compiler.
Machine instructions are simple pieces of code that a computer can execute. These operations include:
- Data Transfers — Move, inputs, outputs
- Arithmetic — Add, subtract, increment, decrement
- Logic — And, or
- String manipulation — Load, store, move, compare
- Control Transfer — conditional, unconditional
- Loop Control — Loop, call, interrupt
- Processor Control — Clear, set
Instructions
CESIL has fourteen machine instructions that constitute the code. These are:
- Load Value — Places value through the computing process
- Store Variable — Turns computing process content into a variable
- Jump Label — Jumps to a different line
- Jineg Label — Negative integer
- Jizero Label — Integer is zero
- Print Literal — Prints the value
- Line — Newline
- In — Allows the user to input
- Out — Outputs stored value (see Store Variable)
- Add Value — Adds values
- Subtract Value — Subtracts values
- Multiply Value — Multiples values
- Divide Value — Divides values
- Halt — Stops program
Code
The virtual CESIL program was compatible with Java. Microsoft dropped support for the language. The code was ported to C# and .Net 2.0 in June 2010. Additionally, some have made their CESIL interpreters.
Loop:
Below is the CESIL code for a loop. Loops are instructions that repeat until a command or specific instruction stops the loop. There are different types of loops in programming, such as a loop, loop, do-while loop, infinite loop, or nested loop. The code below demonstrates a do-while loop. Where the loop repeats until a false:
The “DONE” section is created for user input. Here, the loop is initially loaded as 0, and the total value is stored in the processing system. Then the user inputs a value and is checked if the value is negative. When the negative check is complete, a value is added. The program will loop if the user inputs a negative number (equivalent to true or false).
If-Else Statement:
The closest thing to an If-Else statement in CESIL is the Jineg instruction. Jineg checks if an integer is negative or not. Often, Jineg will accompany other commands to create an if-statement. Within the code of a personal CESIL interpreter that Steve N wrote, the If-Else statement in Jineg is clearer.
While the code instruction is shown inside an interpreter. Jineg is defined, and if it is less than 0 (a negative number), the following command will run. Else, an error is printed for the user. Elsewhere in the code, Steve has written Jizero is equal to 0 and other commands like jump with the If-Else format.
Purpose
The ICL-CES Project is hardly in use today. However, project support boosted CESIL into classrooms and provided young people more awareness around computers. The future of CESIL has met a bitter end but resonates in the hearts of the students that had learned the language in their secondary school.
Argument Revisited
According to student comments, one student had reported that CESIL was not a real assembly language nor set up the user for high-level concepts. While CESIL is not a real assembly language, the similarities are substantial. Like assembly languages, CESIL requires an assembler and machine instructions. We can conclude that the students were taught the basics of the Assembly language.
Admittingly, CESIL does not set up the user for high-level concepts. This is since CESIL communicates directly with the processing system. This method of communication classifies a low-level language. Low-level languages consider the hardware of the processing system they are using. Thus, students would have more knowledge about processing systems and computers than high-level instances.
In general, concepts like if-else and loops were learned effectively through the language. The method of teaching may have been directly or indirectly. Students have also reported learning about variables, data, and decisions from CESIL. We can conclude with the code of CESIL that gaining knowledge of these concepts is possible and likely.
Trends
As programming becomes more advanced, high-level languages are considered more. These languages could be a popular language today, such as Python. Similarly, any object-oriented, scripting or procedural code is preferred today. While CESIL introduced students to code, the language is still low leveled.
Now, secondary students (‘O’ level) have more resources and opportunities to study programming languages. Paper is becoming obsolete; thus, students would find no need to write down code and wait for a return from their professor. They can write onto their personal or school computer and get a response almost instantly.
In addition, the programming workforce is becoming more significant than ever. As secondary students work towards programming, they may find that their curriculum has shifted to high-level languages. This would limit the awareness the students would have to study a low-level language like CESIL today.
Conclusion
All in all, CESIL was written to be simple enough that students could learn it and to introduce assembly languages. We can conclude that CESIL effectively introduced students to code, despite the limited resources when the language was created.
