Programming Languages (CS320) Chapter 1

Programming Languages (CS320)

• Course taught by Dr. Osama Helmy
• Email address: [email protected]

Chapter 1 Topics

• Reasons for studying concepts of programming languages
• Programming domains
• Programming language genealogy
• Language evaluation criteria
• Influences on language design
• Language categories
• Language design trade-offs
• Implementation methods
• Programming environments

Reasons for Studying Concepts of Programming Languages

• Increased ability to express ideas
• Improved background for choosing appropriate languages
• Increased ability to learn new languages
• Better understanding of the significance of implementation
• Better use of already known languages
• Overall advancement of computing

Programming Domains

• Scientific applications: Large floating-point computations, use of arrays (Fortran)
• Business applications: Produce reports, use decimal numbers, characters (COBOL)
• Artificial intelligence: Symbols rather than numbers, use of linked lists (LISP, Prolog, C)
• Systems programming: Need efficiency due to continuous use (C)
• Web software: Eclectic collection of languages: markup (HTML), scripting (JavaScript, PHP), general-purpose (Java)

Programming Language Genealogy

• A diagram showing the relationships and evolution of programming languages.
• Shows the relationships between different languages (e.g., LISP, FORTRAN, C, C++, Java) and their historical developments.

Language Evaluation Criteria

• Readability: The ease with which programs can be read and understood.
• Writability: The ease with which a language can be used to create programs.
• Reliability: Conformance to specifications (i.e., performs to specifications).
• Cost: The ultimate total cost of the language.
• Additional criteria include
  • Simplicity
  • Orthogonality
  • Data types
  • Syntax design
  • Support for abstraction
  • Expressivity
  • Type checking
  • Exception handling
  • Restricted aliasing
  • Portability
  • Generality
  • Well-definedness

Evaluation Criteria: Readability

• Overall simplicity: Manageable set of features and constructs, minimal feature multiplicity, minimal operator overloading.
• Orthogonality: relatively small set of primitives can be combined in a relatively small number of ways. Every possible combination is legal.
• Data types: adequate predefined data types.
• Syntax considerations: flexible composition of identifiers and statements, self-descriptive constructs, meaningful keywords.

Evaluation Criteria: Writability

• Simplicity and orthogonality: few constructs, small number of primitives, small set of rules for combining them.
• Support for abstraction: Ability to define and use complex structures or operations, allowing details to be ignored.
• Expressivity: relatively convenient methods for specifying operations; strength and number of operators and predefined functions.

Evaluation Criteria: Reliability

• Type checking: Testing for type errors.
• Exception handling: Intercepts runtime errors and takes corrective measures.
• Aliasing: Presence of two or more distinct referencing methods for the same memory location.
• Readability and writability: A language that does not support "natural" ways of expressing an algorithm will require the use of “unnatural” approaches, reducing reliability.

Evaluation Criteria: Cost

• Training programmers.
• Writing programs.
• Compiling programs.
• Executing programs.
• Language implementation system (availability of free compilers).
• Reliability.
• Maintaining programs.

Influences on Language Design

• Computer architecture (von Neumann Architecture): Languages are developed around prevalent computer architectures.
• Program design methodologies: New software development methodologies (e.g., object-oriented) led to new programming languages.

Computer Architecture Influence

• Well-known computer architecture: Von Neumann.
• Imperative languages are dominant due to von Neumann computers: Data and programs stored in memory, memory is separate from the CPU, instructions and data are piped from memory to CPU, Basis for imperative languages, variables as model memory cells, assignment statements as model piping, iteration is efficient.

The von Neumann Architecture

• Contains memory, control unit, arithmetic logic unit (ALU), Input/Output (I/O) devices.
• Fetch-execute cycle, initializes program counter, repeat forever, fetch the instruction pointed to by the counter, increments the counter, decodes the instruction, executes the instruction, end repeat.

Programming Methodologies Influences

• 1950s and early 1960s: Simple applications, worry about machine efficiency.
• Late 1960s: People efficiency became important, readability, better control structures, structured programming, top-down design and step-wise refinement.
• Late 1970s: Process-oriented to data-oriented, data abstraction.
• Middle 1980s: Object-oriented programming, data abstraction + inheritance + polymorphism.

Language Categories

• Imperative: Central features are variables, assignment statements, and iteration, support object-oriented programming, include scripting languages, include visual languages (e.g., C, Java, Perl, JavaScript, Visual BASIC .NET, C++).
• Functional: Main means of computation is applying functions to given parameters; examples include LISP, Scheme, ML, F#.
• Logic: Rule-based, rules specified in no particular order, example is Prolog.
• Markup/programming hybrid: Markup languages (HTML, XML) extended to support some programming, examples include JSTL, XSLT.

Language Design Trade-Offs

• Reliability vs. cost of execution (e.g., Java demands that all array references be checked for proper indexing).
• Readability vs. writability (e.g., APL provides many powerful operators).
• Writability (flexibility) vs. reliability (e.g., C++ pointers).

Implementation Methods

• Compilation: Programs are translated into machine language (includes JIT systems). Used for large commercial applications.
• Pure Interpretation: Programs are interpreted by another program (interpreter). Used for small programs or when efficiency isn't a concern.
• Hybrid Implementation Systems: Compromise between compilers and pure interpreters. Used for small and medium systems when efficiency isn't the first concern.
• Just-in-Time (JIT) Systems: Initially translates programs to intermediate language. Then compiles the intermediate language of subprograms into machine code when they are called. Machine code version is kept for subsequent calls; widely used for Java and .NET.
• Preprocessors: Preprocessor macros specify code from another file to be included. They process the program before compilation (example: C preprocessor #include, #define)

Programming Environments

• Collection of tools used in software development (e.g., UNIX, Microsoft Visual Studio .NET, NetBeans).
• UNIX: An older OS with a tool collection, often used through a GUI (e.g., CDE, KDE, GNOME).
• Microsoft Visual Studio.NET: Large, complex environment used for Web and non-Web applications in .NET language.
• NetBeans: Related to Visual Studio.NET, except for applications in Java.

This quiz covers key concepts from Chapter 1 of the Programming Languages course CS320. Topics include reasons for studying programming languages, programming domains, and language design. Enhance your understanding of programming language evaluation and design trade-offs.