Code

Niklaus Wirth: A Biography of the Creator of the Pascal Programming Language and More

Niklaus Wirth: A Biography of the Creator of the Pascal Programming Language and More

Free Python Course ➞ Mini-course for beginners and experienced coders. 4 cool projects in the portfolio, live communication with the speaker. Click and find out what you can learn in this course.

Learn More

Niklaus Wirth, the future world-famous programmer, was born in 1934 in Winterthur, Switzerland, the son of a schoolteacher. From an early age, he showed an interest in aircraft modeling and rocket building, even attempting to produce rocket fuel in the school basement. This passion became the foundation for his later career in programming and programming language development. Wirth made significant contributions to the development of computer science, particularly through his innovations in algorithms and systems programming.

Dreams of the sky remained with Wirth throughout his life. He was so strongly attached to this desire that his colleague, Professor Donald Knuth, once noted: "Niklaus always wanted to build airplanes, and he used programming languages ​​and microcomputers merely as tools to achieve this goal." These words highlight how important the idea of ​​creating flying machines was for Wirth, and how he used his knowledge of programming to realize his dreams.

Niklaus in his youth Photo: Wikimedia Commons

The young aviation enthusiast soon began developing control systems for model aircraft, which led him to a passion for electronics and programming. This transition was an important stage in its development, opening up new horizons in the world of aircraft modeling and technology.

Swiss Federal Institute of Technology Zurich Photo: Wikimedia Commons

In In 1954, Wirth entered the Swiss Federal Institute of Technology in Zurich (ETH). He then continued his education in Canada and California, where he successfully defended his dissertation on the Algol programming language. This period in his life became fundamental for the further development of his career in computer science and programming.

What was wrong with Algol 68

Soon, Wirth began his work on the IFIP committee, where he worked on the standardization of the Algol programming language. At that time, Algol 60 enjoyed considerable popularity in Europe both among programmers and as a means of describing algorithms in scientific research. However, the language had many shortcomings and was in dire need of revision and improvement.

Virth in the 1960s Photo: Wikimedia Commons

Niklaus and Charles Hoare, a scientist from Oxford University, developed the Algol W programming language. This language was an improved version of Algol that corrected the shortcomings of the original and added important features. Although the project received positive reviews from many scientists, the programming standards committee ultimately rejected it. Algol W nevertheless influenced the further development of programming languages ​​and became the basis for a number of subsequent developments.

In 1968, a new programming language, Algol 68, was introduced. This language generated considerable controversy among developers, as even experienced programmers noted its complexity and bulk. Niklaus Wirth's partner, Charles Hoare, described Algol 68 as obscure and overly ambitious, highlighting its complexity and shortcomings in perception. Despite this, Algol 68 influenced the development of programming languages ​​and became an important milestone in the history of computing.

Calculating the date of the next day in the Algol 68 programming language is an important task. To determine the next date, we need to consider the number of days in the month and the transition to the next month or year. Algol 68 allows us to use simple arithmetic operations and conditions to implement this logic. First, we need to specify the current date, including the day, month, and year. Then, by incrementing the day by one, we can check whether it exceeds the number of days in the current month. If the day exceeds the maximum number of days, we should reset it to the first of the next month and, if necessary, increment the year if the month equals 1.

Leap years, where February has 29 days, must also be taken into account. Algol 68 can implement leap year checking to correctly calculate the next day's date. Thus, correctly calculating the next day's date in Algol 68 requires taking into account many factors, such as the number of days in a month and leap years, making the task interesting and educational.

Some committee members, including Wirth, expressed criticism of Algol 68, pointing out its shortcomings as a tool for reliably creating complex programs. In their report, they noted that the language fails to cope with the tasks for which it was designed. However, the IFIP committee embargoed the document, raising further questions about the transparency and objectivity of programming language evaluation.

Algol 68 failed to achieve the popularity of Algol 60 and failed to displace such widely used programming languages ​​as Fortran and COBOL. In the academic community, it was perceived as too complex and cumbersome, which led to its abandonment. Despite its innovative concepts, Algol 68 failed to gain the trust of developers and educators, resulting in its limited adoption.

Charles Anthony Hoare Photo: Wikimedia Commons

How Pascal Was Born

Until 1967, Niklaus Wirth worked at Stanford, where he developed the PL360 language for the IBM System/360. Afterwards, he returned to the University of Zurich, where he soon took up a position as a professor of computer science. This period became one of the most productive in his career, marked by significant achievements in the field of programming and language development.

In Switzerland, Wirth sought to create an analogue of Stanford University. He was active in both scientific and organizational activities, successfully introducing Stanford's traditions and customs to ETH. This improved the quality of education and research, and also attracted attention to the Swiss university on the international arena. As a result of Wirth's work, ETH became a center of innovation and advanced technology, which contributed to the development of the scientific community in the country.

Wirth did not like either Algol or other programming languages ​​​​existing at the time. He considered them too complex and inefficient. In his opinion, these languages ​​were characterized by redundancy and a lack of logic, which complicated the programming process and reduced developer productivity.

In the 1960s and 1970s, programming languages ​​were perceived as a means of communication between humans and machines, which imbued them with philosophical meaning. In contrast, Niklaus Wirth believed that programming languages ​​should be strictly structured sets of rules for controlling computers. His work resulted in the creation of the Pascal language, named after the eminent physicist Blaise Pascal. The development of Pascal was an important step in the evolution of programming, as the language ensured clarity and clarity in writing code, which facilitated more effective interaction between developers and computers.

During his work at IFIP, Niklaus Wirth met the eminent scientists Edsger Dijkstra and Tony Hoare. Drawing on the principles of structured programming proposed by Dijkstra and the mathematical foundation developed by Hoare, Wirth created the Pascal programming language. This language was based on his own developments, including Algol W, which integrated best programming practices and increased the efficiency of software development. Pascal became an important tool in teaching programming and had a significant influence on subsequent languages, helping to popularize a structured approach to development.

Edsger Wiebe Dijkstra Photo: Wikimedia Commons

In 1968, Niklaus Wirth and his team developed the concept of the Pascal programming language and then began creating a compiler. They developed the P-machine, which used intermediate P-code, which made Pascal portable across various platforms. Interestingly, the Pascal compiler was written in Pascal itself. Later, James Gosling used the ideas of the P-machine to create the Java language and the Java Virtual Machine (JVM), which was an important step in the development of programming.

In 1971, Niklaus Wirth introduced the Pascal programming language, which became known as a compact language with support for structured programming and structured data. The main goal of Pascal's development was to teach students the basics of professional programming, making it ideal for educational institutions. However, the language also proved to be very effective at solving complex practical problems, which contributed to its popularity in various areas of software development. Pascal continues to be an important tool in teaching programming and developing software solutions.

An example of code to print "Hello, world." in the Pascal programming language looks like this:

«`pascal
program HelloWorld;
begin
writeln(‘Hello, world.’);
end.
«`

This simple example demonstrates the basic syntax of Pascal, where a program begins with the keyword `program` followed by the program name. Within the `begin` and `end` blocks is the `writeln` command, which is responsible for printing text to the screen. Using Pascal to teach the basics of programming helps develop logical thinking and an understanding of code structure.

In just two or three years, the Pascal programming language has become very popular among programmers and educators. In the 1990s, it was considered one of the most widely used algorithmic languages. Its simplicity and structured approach made it an ideal choice for teaching programming, as well as for developing various software applications. Pascal remains an important part of programming history and serves as the basis for many modern languages.

Wirth's Other Projects: Modula-2 and Lilith

Niklaus Wirth continued to develop structured programming languages, and his next significant development was Modula. This programming language combined modularity and parallel programming capabilities, which made it innovative for its time. However, despite its merits, Modula did not gain widespread popularity in the programming world.

In 1977, the scientist decided to develop a complete computer system, including a personal workstation, microcode, compiler, operating system, and utility programs aimed at convenience for both users and developers. This project was called Lilith and became a significant step in the development of computer technology. Lilith demonstrated what an integrated system could look like, capable of meeting the needs of users and developers, which in turn influenced subsequent developments in computing.

At the time, the idea was truly revolutionary. Operators performed calculations on large mainframes, providing access to users through terminals. Only two or three users could work on a single machine at a time, while others waited their turn to process the data. This model limited the speed of operation and the efficiency of using computing resources, which made innovation in the field of computing especially relevant.

IBM System/370 Mainframe Photo: Bettmann / Getty Images

The idea for Lilith came to Wirth after visiting Xerox PARC in California, where he encountered the concept of a personal workstation. There, he saw a device with a monitor, mouse, and a separate disk, allowing each user to have their own computer without having to share resources with others. This impression left a significant impression on Niklaus, and he decided to implement a similar solution at his home in Zurich. Thus, Lilith became one of the first examples of personal computers, which had a significant impact on the development of technology and the user experience.

In 1979, a team of electronics engineers from ETH developed the Lilith personal computer, which used four sets of Am2901 microprocessors and processed 16-bit words. This project was a significant step in the history of computing, demonstrating the capabilities of personal computers in the field of data processing.

Personal station Lilith Photo: Wikimedia Commons

Niklaus and his team were engaged in The development of a general-purpose language for systems and application programming. An important part of their work was the compiler, as well as the operating system for Lilith. They also created utilities and the first applications that demonstrated the capabilities of this language. The development of a general-purpose language opened new horizons in programming, providing developers with tools for creating efficient and powerful software solutions. Modula-2 was developed with the aim of combining application and systems programming. It includes the SYSTEM pseudo-module, which is designed to perform low-level operations. This language structure allows for the efficient development of both application and system applications, providing a high level of abstraction and control over resources. Finding the greatest common divisor (GCD) in the Modula-2 programming language is an important problem in the field of mathematical arithmetic and programming. The greatest common divisor of two numbers is the largest number by which both numbers are divisible without a remainder. Modula-2 can implement the Euclidean algorithm for calculating the greatest common divisor (GCD), which is efficient and simple.

To implement the algorithm, you need to create a function that takes two integers as parameters. This function uses a recursive approach, where the GCD is calculated by dividing the larger number by the smaller one, and then replacing the larger number with the remainder until one of the numbers becomes zero. The result will be the second number, which at that point will be the GCD.

An example of Modula-2 code for finding the greatest common divisor might look like this:

«`
MODULE GCD;

PROCEDURE GCD(a, b: INTEGER): INTEGER;
BEGIN
IF b = 0 THEN
RETURN a;
ELSE
RETURN GCD(b, a MOD b);
END;
END GCD;

BEGIN
(* Example usage *)
VAR result: INTEGER;
result := GCD(48, 18);
(* Print the result *)
END GCD.
«`

This code demonstrates how simple it is to implement an algorithm for finding the GCD in Modula-2. By using such a function, developers can easily integrate it into more complex programs that require working with fractions, simplifying numbers, or other mathematical operations.

The Medos operating system was created for Lilith, which includes software support for the display and a text editor with a functional drop-down menu.

In 1980, ETH students built the first 20 computers out of a total of 60. In 1982, the Lilith computers were connected to a server and an Ethernet-based network. With the introduction of Canon LBP-10 laser printers, Lilith computers became the first in Europe to fully utilize their capabilities, including support for fonts, graphics, scanned images, and electronic circuits.

Wirth later remarked that if the Swiss computer industry had been able to fully realize Lilith's potential, it could have earned a significant place in the history of technology.

In 1984, Niklaus Wirth received the Alan Turing Award for developing the Lilith and Modula-2 programming languages. This award is considered the equivalent of the Nobel Prize in computer science and recognizes outstanding achievements in the field. Wirth is known for his contributions to programming language design, which played a vital role in the development of modern computing technology.

The Modula-2 programming language was used to develop the OS/400 operating system for the IBM AS/400 platform. Also, compilers were created in this language for various personal computers, including PC and Macintosh, as well as for IBM RS/6000 workstations and IBM and SGI mainframes. Modula-2 demonstrates its versatility and efficiency in creating software for a variety of computing systems.

Despite its simplicity and high efficiency, the Modula-2 programming language was not widely used and was unable to displace its predecessor, Pascal. One of the reasons for this may be that the little-known Lilith system was unable to exert the proper influence on the promotion of the language.

In 1988, Niklaus Wirth and Jürg Gutknecht developed the Oberon programming language, based on Modula-2, for use on the Ceres station. Later, they presented an improved version of the language called Oberon-2, which expanded the capabilities and functionality of the original Oberon.

In 1996, the scientist created the Lola programming language, designed for describing and modeling digital electrical circuits. This language has become an essential tool in the design and verification of digital systems, enabling engineers to precisely specify the structure and behavior of complex electronic devices. Lola facilitates the development and testing process, making it popular in the microelectronics and digital logic industries.

At the end of his professional career, Wirth, pursuing his passion from his youth, supported ETH mechanics in developing the first drone prototype. He not only designed but also programmed the onboard computer, significantly optimizing its energy consumption, reducing it by almost tenfold.

In 1999, at the age of 65, Niklaus Wirth retired from his career. He dedicated more than three decades to his work at the Swiss Federal Institute of Technology (ETH), where he held various positions, from professor to dean of the Faculty of Computer Science. He later also headed the ETH Institute for Computer Systems. Wirth is known for his significant contributions to programming and language design, making him one of the key figures in the history of computer science.

Niklaus Wirth today Photo: Ocg.at / Flickr

Niklaus Wirth continues his scientific work and remains a significant figure in the field of computer science. He is the author of numerous classic textbooks and reference books, which have become the foundation for many students and specialists in this field. Wirth is currently a member of several national academies and, since 2007, has held the title of Honorary Doctor of the Russian Academy of Sciences. His contributions to computer science and educational methodologies continue to inspire a new generation of researchers and developers.

Read also:

  • The First Female Programmer - The History of Programming
  • Test: Which IT Specialist from Movies Are You Like?
  • Recursion All Around Us: People, Cathedrals, and Romanesco Cabbage