Languages for Web applications

Lecture Notes for CS349W
Fall Quarter 2008
John Ousterhout

No one builds Web applications in C or C++
Many new languages:
- PHP
- Ruby
- Javascript
All Web languages appear to be more dynamic, interpreted:
- Java
- Python
Why is this?

A brief history of programming languages

First: assembly languages
- Low-level: 1 line of code generates 1 machine instruction
- Every detail exposed to the programmer: register allocation, procedure call sequences, etc.
- Different language for every architecture
Starting in the late 1950's: compiled languages, eventually leading to system programming languages:
- Fortran -> Algol -> PL/1 -> Pascal -> C -> C++ -> Java
- Higher-level:
  - 1 line of code generates ~5 machine instructions
  - Details such as register allocation and stack management are but automatically, invisible to the programmer
  - Higher programmer productivity: code lines/day is mostly independent of language
- Strong typing:
  - Programmer declares in advance the characteristics of variables, which limits how they can be used
  - Compiler enforces the declarations, restricts usage
  - Benefits of strong typing:
    - Clarifies usage
    - Reduces errors
    - Allows compilers to generate more efficient code
  - Note: internally, computers are untyped: the meaning of a value is determined by how it is used, not by any advance declaration (e.g. a memory word can be an instruction, an integer, character data, etc.)
- Typically used to build things from scratch, though large library packages are becoming more common.
Scripting languages:
- Many examples dating back to the 1960's: JCL, Unix shells, Visual Basic, Perl, Tcl, Python, Javascript, ...
- Different style of programming: typically used to combine pre-existing components:
  - sh: components are filter programs
  - Tcl/Tk: components are user-interface controls
  - Javascript: components are DOM elements
- Typeless:
  - Any variable can hold any kind of value
  - Makes composition and reuse easier: no a priori restrictions on how things can be used
  - Typically string oriented:
    - Automatic conversion to/from strings
    - Hash tables
    - Regular expressions
  - Tcl example:
```
button .b -text Hello! -font {Times 16} -command {puts hello}
```
  - MFC code to set font only:
```
CFont *fontPtr = new CFont();
fontPtr->CreateFont(16, 0, 0, 0,700, 0, 0, 0,
        ANSI_CHARSET, OUT_DEFAULT_PRECIS,
        CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
        DEFAULT_PITCH|FF_DONTCARE,
        "Times New Roman");
buttonPtr->SetFont(fontPtr);
```
- Scripting languages are typically interpreted:
  - Less efficient than system programming languages
  - Allows dynamic generation of code, fungibility of code and data
  - Dynamic/flexible facilities make compilation hard:
    - Hash tables
    - Variable-length strings, regular expressions
    - Dynamic addition/modification of code
- Scripting languages allow 5-10x faster development, 5-10x less code (see IEEE Computer paper for details):
  - Higher-level: 1 statement generates 100-1000 instructions
  - Easy to hook things together: avoids boilerplate and conversion code required by system programming languages
  - Interpretation provides fast turnaround during development
Different tools for different tasks:
- Use system programming languages for:
  - Low-level components
  - Things like operating systems where efficiency is critical
  - Complex data structures and algorithms
- Use scripting languages for:
  - Integration
  - String-oriented tasks

Languages for the Web

So far, the Web has been dominated by scripting languages
Java is the one exception:
- Mostly a system programming language
- Higher-level than its predecessors:
  - Variable-length strings
  - Automatic string conversion (toString methods)
  - Run-time introspection
  - Dynamic class loading
  - Garbage collection
  - Compiled to byte codes, then interpreted or just-in-time compiled to machine code
- But, strongly typed, no "eval"
- Java-based Web development frameworks (so far) have been complex and clunky
Ideal language would combine characteristics of both scripting and system programming:
- Want a high degree of layering: will pure scripting languages be too slow? (e.g. concerns about Ruby)
- I like having types in situations where the type really is fixed (easier to understand code).
- Want the flexibility, string-orientation of scripting.