Outline

• The Art of Language Design
• Types of Programming Languages
• In-Class Exercise
• The Study of Programming Languages
• Compilers versus Interpreters

Inroduction

• On Monday, we said: "A programming language is a notational system for describing computations in a machine readable and in a human readable form."
• We explored what we meant by computation and what we meant by machine readable and human readable.
• Today, we introduce the study of programming languages...

The Art of Language Design

• Today, there are thousands of high-level programming languages.
• It is likely new languages will continue to emerge, so it is interesting to ask why?
• Here are some possible reasons:
  • Evolution CS is new, we are constantly finding better ways of doing things. For example, in early programming languages there was extensive use of the goto statement (Fortran, Cobol, BASIC). This made programs hard to read and maintain. Later block structured programming languages such as Ada, Pascal, and Ada used nested block structures instead of goto.
  • Special Purposes Some languages are designed for a specific programming domains. For example, Lisp is good for symbolic data, Icon and Awk are goind for string manipulation, C is good for low-level systems programming, and Prolog is good for reasoning about logical relationships among data.
  • Personal Preference Different people like different things. Some people love the tersenees of C, some hate it. Some people like to thing recursively, other prefer iteration, etc.

What Make a Language Successful

• Expressive Power. Most languages we will consider are Turing complete. However, the available abstractions in a language can make tasks easier or harder. For example, it is easier to program using variables rather than referring to the address of memory locations where data is stored in RAM.
• Ease of Use for the Novice. Some languages have an easier to learn syntax or eliminate issues found in earlier languages, etc. For example, Java is generally easier to learn than C++ because its inheritance model is simpler, and it uses a garbage collector rather than manual allocation and deallocation of memory.
• Ease of Implementation. One reason BASIC was successful was that it could implemented on tiny machines with limited resources. So it ended up being the language that came with computers like the Zx81, Commodore Pet, Apple II, etc.
• Standardization. If a language has been standardized by an independent third party, then many vendors can write to this standard and compete to improve the compilers and tools for the language. They can also help market the language. This definitely helped C.
• Open Source. If the source code for a language implementation is open, then other people can see how to write a compiler, etc for it. This is different than free which is often a legal guarantee that you are allowed to manipulate the source as desired only if you are willing to let other people manipulate the derived product similarly. C also benefited from open source and free implementations.
• Excellent Compilers. A language that lets you easily compile to fast code to do what you want, might be better than language that might be more expressive but compiles to slower code. One of the reasons that Fortran has remained popular even though it is the first mainstream high level programming language is because of this.
• Economics, Patronage, and Inertia. If a language has a company advocate with deep pockets and marketing, it can last for a long time and stay moderately popular. For example, C#, F#, Visual Basic - Microsoft; Java - Sun/Oracle, Google; Go, Kotlin - Google, PHP - Facebook, Yahoo; Swift, Objective-C - Apple; Javascript, Rust - Netscape/Mozilla; PL/I - IBM, Ada, Cobol - Department of Defense.

Kinds of Programming Languages 1

• Functional. These languages employ a computational model based on the recursive definition of functions. They derive from the lambda calculus of Alonzo Church developed in the 1930s. Examples include, Lisp, Scheme, ML, Haskell, Scala, F#. Here is an example Scheme implementation of GCD:

  (define (gcd u v) (if (= v 0) u (gcd v (modulo u v))))
  

• Dataflow. These languages model computation as the flow of information (tokens) among primitive functional nodes. As node are triggered by the arrival of input tokens, and can operate concurrently, these kinds of languages are often used to model parallelism. Examples include: Id, Val, and to a lesser degree Sisal.
• Logic or Constraint Based. These languages are inspired by predicated logic. They model computation as an attempt to find values that satisfy certain specified relations, using goal-oriented search through a list of logical rules. Examples include Prolog, SQL, XSLT. An example Prolog program for GCD might look like:

  gcd(U, V, U) :- V = 0. 
  gcd(U,V, X) :- not (V =0), Y is U mod V, gcd (V,Y,X).
  

Kinds of Programming Languages 2

• von Neumann. These are perhaps the most common kind of language. They are based on statements that influence the subsequent computation via the side-effect of changing the value of memory. Examples include BASIC, Fortran, Ada, C. A C Program for GCD might look like:

  int gcd(int a, int b) { 
    while (a != b) {
      if (a > b) a = a - b;
      else b = b - a; 
    }
    return a;
  }
  

• Object-Oriented. These languages trace their roots to Simula 67. Most are similar to von Neumann languages, but have an object mechanism for grouping structured data together with functions used to manipulate that structure. Examples include Smalltalk, C++, Objective-C, Java. It is also possible to add object like features to functional languages. For example, CLOS for Lisp, OCaml for ML.
• Scripting. These languages are distinguished by their emphasis on "gluing together" components drawn from some surrounding context. Such languages are often purpose built. For example, csh and bash were created as input languages for job control (shell) programs; PHP and JavaScript were made for the generation of dynamic web content; Lua is widely used to control computer games.

In-Class Exercise

• For the Scheme and Prolog examples of GCD just given, show step by step how they would compute the GCD of 14 and 30.
• Please post your solution to the Aug 25 In-Class Exercise Thread.

The Study Programming Languages

There are many reasons why a good programmer would be interested in the systematic study of programming languages:

• Understand obscure features. Languages often have core features that are used often (for, while loops, etc.) Then they have less common features. For example, in C++, union types, multiple inheritance, variable number of arguments functions are less often used features. Understanding the common basic concepts in all programming languages, means you can guess that a language has an obscure feature, even if you don't know its syntax and then look it up.
• Choose among alternative ways to express things. Often a language has multiple ways to express/implement the same thing. In order to choose amongst alternatives, it is important to know their costs in terms of their underlying implementations. For example, in certain poor compilers, x*x might be faster than x**2.
• Make good use of debuggers, assemblers, linkers, and related tools. Although one advantage of high level programming language is that you don't have to sweat the low level details, some times, for tenacious bugs, you might need to understand how things work at a lower level.
• Simulate useful features in languages that lack them. For example, C is not usually considered object oriented, but if you want to program in an object oriented way in C, it is possible by using struct's, together with function pointers.
• Make better use of language technology whenever it appears. People are constantly creating new file formats for documents, spreadsheets, wiki's, markdown languages, drawing graphics scene in games, etc. Knowing how to write one's own parser and analyzer for new formats can be extremely useful.

Compilers versus Interpreters

• The compilation and execution of a program is represented by the following diagram:
  
• The compiler translates the high-level program into an equivalent target program (usually in machine language), and then goes away. The user at some later point tells the OS to run the target program on a computer that knows how to process the given machine language code.
• An interpreter by contrast operates according to the following diagram:
  
• The interpreter reads statements more or less one at a time, executing them as it goes. This can be viewed at the interpreter acting as virtual machine for the high level language.

Consequences of Interpretation versus Compilation

• In general, interpretation leads to greater flexibility and diagnostics than does compilation.
• Interpreters also tend to be better able to cope with languages in which characteristics of the program such as size, types, and names of variables can depend on the input data. Lisp and Prolog are very hard to implement without interpretation.
• Delaying decisions about program implementation until run time is known as late binding. We will talk about this in depth as the semester goes along.
• Compilation generally leads to better performance -- decisions made at compile no longer have to be made each time the program is run.

Virtual Machines

• Many modern languages are implemented using a mixture of both compilation and interpretation as illustrated by the diagram below:
  
• We compile to a program in some kind of intermediate language. That program can in turn be executed on a virtual machine.
• Pascal is a famous early example of a language that used a virtual machine for its P-code intermediate language.
• Java is popular modern language that typically makes use of a virtual machine.