Programming Language Concepts

• Reasons for studying concepts of programming languages include increased capacity to express ideas and improved ability to choose an appropriate language
• Knowledge of abstraction mechanisms in languages helps programmers to more easily solve problems
• General-purpose programming languages are equivalent in terms of capability, but some are better suited for certain applications
• COBOL was designed for business applications
• FORTRAN was designed for scientific applications
• C was designed for systems programming
• SNOBOL was designed for string processing
• Learning new languages is an important skill, given the frequent rise in popularity of programming languages
• Understanding implementation issues helps in figuring out subtle bugs and tweaking programs to be more efficient
• Knowledge of language constructs in general helps programmers understand and use features in their "favorite" language
• Broader knowledge of programming language concepts can improve the software industry's adoption of languages based on their merits
• Algol 60 never gained popularity in the U.S. despite being superior to FORTRAN
• Eiffel is not particularly popular despite being a great language

Programming Domains

• Scientific applications involve arithmetic on real numbers, arrays/matrices, and "counting" loops; FORTRAN is used in this area
• Business applications involve decimal arithmetic and elaborate reports; COBOL was designed for this
• Artificial Intelligence applications require symbolic manipulation and use of lists; LISP and Prolog are suitable for this
• Systems programming requires efficiency and low-level operations; C is commonly used
• Web software needs good string processing capabilities; PHP and JavaScript have become popular

Language Evaluation Criteria

• This includes readability, writability, reliability, and cost, impacting the software development process and maintenance

Readability

• Refers to the ease with which programs can be understood
• Writing hard-to-understand programs is possible in any language
• A language's characteristics can make programs easier or more difficult to read

Simplicity

• Having too many basic constructs/features can make a program harder to read
• Code with very few constructs (e.g., assembly language) can be hard to read
• Feature multiplicity refers to multiple ways of doing the same operation
• Operator overloading can aid readability if used with discretion

Orthogonality

• Refers to the property of being independent
• Features/constructs are orthogonal if they can be used freely in combination
• Orthogonality is lessened if combinations are forbidden or lack evident meaning from components
• A function in C cannot return an array type or a function type
• In C, arrays can hold values of any type except function or void types
• Parameters to functions in C are passed "by value," except for arrays which are passed "by reference"
• In the expression a + b in C, the meaning of + depends on whether a is a pointer type
• It is possible to have too much orthogonality
• Algol 68 had extreme orthogonality

Data Types

• Adequate facilities for defining data types and structures aid readability
• Early FORTRAN lacked record/struct constructs
• Early versions of C had no boolean type

Syntax Design

• Identifier forms should not be too restrictive on length
• COBOL identifiers can include dashes, which can be confused with the subtraction operator
• Special words like "while," "if," and "class" have special meaning and may or may not be reserved

Writability

• Measures how easily a language can develop programs for a chosen problem domain

Simplicity and Orthogonality

• Sebesta favors a small number of primitive constructs and consistent rules for combining them

Support for Abstraction

• Allows programmers to define complicated structures/operations and to ignore implementation details
• It is a key concept in modern language design
• Data abstraction and process is procedural abstraction

Expressivity

• Is enhanced by powerful operators that accomplish a lot in a few lines of code
• APL includes operators that apply to matrices
• Assembly/machine languages lack expressivity
• Functional languages tend to be very expressive

Reliability

• Performing to specifications under all conditions

Type Checking

• Refers to testing for type errors during compilation or execution
• The former is preferable because the latter is more expensive
• Java uses tight type checking during compilation

Aliasing

• Having two or more distinct names that refer to the same memory cell
• Also hurts readability/transparency

Readability and Writability

• Influence reliability because you are more likely to produce reliable programs when using these properties

Cost

• Contributes to the cost of using a language including training programmers and writing and maintaining programs and compiling and executing programs.
• Optimizing compilers take longer to work but yield programs that run more quickly
• Software failure could be expensive

Other Criteria:

• Portability is the ease with which programs can work on one platform and can be modified to work on another
• Generality is the applicability to a wide range of applications
• Well-definedness is the completeness and precision of the language's official definition.

Language Design Trade-Offs

• A language feature that enhances a score on one criterion may lower it on another such as Reliability vs cost (of execution), Writability vs readability and Writability vs reliability

Influences on Language Design

• Computer Architecture reflects a computer's architecture
• Assembly language is a thin layer of abstraction to make programming easier

Programming Methodologies

• Advances in methods of programming also have influenced language design
• Refinements in thinking about flow of control led to better selection and loop constructs
• This is called Structured Programming

Language Categories

• Imperative, object-oriented, functional, and logic are the four categories usually recognized
• C++, Java, and Ada 95 are imperative

Implementation Methods

• Computers execute machine code to run code written
• Software translates into machine code using a translator
• General translation methods are: compilation, interpretation, and a hybrid

Compilation

• A compiler translates each compilation unit into an object module containing object code
• Object code is like machine code, except external and relative references are not yet in machine code form
• A linker links object modules together to resolve external references
• The result of a linker is a load module
• A relocating loader puts the code into memory and replaces instances of relative references with memory addresses
• The lexical analyzer transforms the text comprising a program into tokens corresponding to the logical units occurring in the program
• The syntax analyzer takes the sequence of tokens and figures out the program's structure

Pure Interpretation

• Here the interpreter is a program that simulates a computer whose "native language" is X and repeatedly fetches the "next" instruction, decodes it, and executes it

Hybrid

• Here a program is translated by a compiler into an intermediate language
• Then the intermediate code is interpreted
• Java programs operate using hybrid because the intermediate language is java bytecode

Names

• Names, bindings, type checking, and scopes

Introduction

• Imperative languages are abstractions of von Neumann architecture
• Memory stores both instructions and data
• A processor provides operations for modifying the contents of memory

Names

• Design issues for names cover the maximum length and whether connector characters are allowed and whether names are case sensitive

Name Forms

• A name is a string of characters used to identify some entity in a program
• Fortran 1 has a maximum of 6
• Cobol has a maximum of 30
• Fortran 90 and ANSI C has a maximum of 31
• Ada and Java has no limit
• C++ has no limit, but implementers often impose a length limitation because they do not want the symbol table to be too large

Special Words

• A keyword is a word that is special only in certain contexts.
• A reserved word is a special word that cannot be used as a user-defined name.

Variables

• A variable is an abstraction of one or more memory cells
• Variables can be characterized as a sextuple of attributes: name, address, value, type, lifetime, scope
• Not all variables have names such as Anonymous
• The memory address with which it is associated
• If two variable names can be used to access the same memory location, they are called aliases

Type

• Determines the range of values of variables and the set of operations that are defined for values of that type

Value

• The value of a variable is the contents of the memory cell or cells associated with the variable
• A variable's value is sometimes called its r-value because that is what is required when a variable appears in the right side of an assignment statement.

The Concept of Binding

• The address is the l-value of a variable
• The value is the r-value of a variable
• A binding is an association such as between an attribute and an entity
• Binding time is the time at which a binding takes place
• Language design time and Language implementation time and and Compile time and Load time and Runtime are all possible binding times

Binding Attributes to Variables

• A binding is static if it first occurs before run time and remains unchanged throughout program execution.
• A binding is dynamic if it first occurs during execution or can change during execution of the program.
• If static, the type may be specified by either an explicit or an implici

Dynamic Type Binding

• Javascript and PHP
• Defined through an assignment statement
• High cost (dynamic type checking and interpretation)
• Type error detection by the compiler is difficult, there is No error is detected by the compiler or run-time system.

Type Inference (ML, Miranda, and Haskell)

• Rather than by assignment statement, types are determined from the context

Storage Bindings & Lifetime

• Allocation - getting a cell from some pool of available cells. •. Deallocation - putting a cell back into the pool.
• The lifetime of a variable is the time during which it is bound to a particular memory cell
• There are different categories of variables by lifetimes: static,stack-dynamic, explicit heap-dynamic, and implicit heap-dynamic

Scope and Lifetime

• The scope of a var is the range of statements in which the var is visible.
• A var is visible in a statement if it can be referenced in that statement
• Local var is local in a program unit or block if it is declared there
• Non-local var of a program unit or block are those that are visible within the program unit or block but are not declared there.
• Binding names to non-local vars is called static scoping

Referencing Environment

• It is the collection of all names that are visible in the statement.
• In a static-scoped language, it is: local variables plus all of the visible variables in all of the enclosing scopes Named Constants

Scope and Lifetime

• It is a var that is bound to a value only at the time it is bound to storage; its value can't be change by assignment or by an input statement.
• Readability and modifiability is it´s advantage

Variable Initialization

• The binding of a variable to a value at the time it is bound to storage is called initialization.
• Initializati is often done on the declaration statement