Programming Languages: Preliminary Concepts

Unit 1: Preliminary Concepts

• Reasons for studying programming languages: enhanced expression, improved language selection, faster learning, deeper implementation significance, and overall computing progress
• Programming domains include scientific applications (Fortran), business apps (COBOL), AI (LISP), systems programming (C), and web software (XHTML, PHP, Java)
• Key language evaluation criteria are readability, writability, reliability, and cost

Readability

• Readability depends on overall simplicity (manageable features, few multiplicities, minimal overloading), orthogonality (construct combinability), control statements, data structure adequacy, and clear syntax (identifier forms, special words)

Writability

• Writability hinges on simplicity/orthogonality, abstraction support, and expressivity (convenient operation specification)

Reliability

• Reliability relies on type checking, exception handling, and avoiding aliasing (multiple referencing methods), and readability/writability balance

Cost

• Cost involves programmer training, program writing effort, compilation expenses, execution processes, language implementation system availability, reliability factors, and maintenance

Other Criteria

• Portability (implementation movement ease),Generality (application range) and well-definedness (official completeness/precision)

Influences on Language Design

• Influences on language design: prevailing computer architecture (Von Neumann) and development methodologies

Computer Architecture

• Von Neumann architecture stores data/programs in memory, separates memory from CPU, pipes instructions/data, forms the imperative language basis, models memory cells with variables and models piping with assignment statements

Programming Methodologies

• Programming methodologies have evolved from machine efficiency (1950s-60s) to people efficiency with better control structures (late 1960s), process-oriented to data-oriented (late 1970s), and OOP (mid 1980s, through data abstraction)

Language Categories

• Central imperative features: variables, assignments, iteration (Examples: C, Pascal).
• Functional languages apply functions to parameters (Examples: LISP, Scheme).
• Logic languages use rule-based specifications (Example: Prolog).
• Object-oriented languages promote data abstraction, inheritance, delayed bindings (Examples: Java, C++).
• Markup languages define web layout (Examples: XHTML, XML).

Language Design Trade-Offs

• Reliability is often traded off against execution cost (e.g., Java's array indexing checks).
• Readability can conflict with writability (e.g., APL's compact code).
• Writability & flexibility can be at the cost of reliability (ex: C++ pointers)

Implementation Methods

• Compilation translates programs into machine code
• Pure interpretation involves execution by another program, the interpreter
• Hybrid systems are a compromise between compilation and interpretation

Compilation Phases

• Lexical analysis converts characters to lexical units
• Syntax analysis converts lexical units to parse trees
• Semantic analysis generate intermediate code
• Code generation provides machine code

Compilation Terminology

• Load modules merge the users and the system
• Linking loads the program system for users

Code Execution

• Fetch-execute cycles on a von Neumann architecture

Neumann Bottleneck

• Speed limitations exist between computer memory, and processors

Pure Interpretation

• Pure interpretation: no translation, better error display and implementations due to memory constraints

Hybrid System

• Intermediate languages offer compiled- before-interpretation features

Just-In-Time Compilation

• Compiles code to an intermediate
• Compiles on machine code

Preprocessors

• Preprocessor macros allow for code inclusion from other files, expanded before compilation.

Syntax and Semantics

• Syntax represents form/structure for expressions, statements, program units.
• Semantics stands for meaning of the same syntax.
• Syntax and semantics are languages definitions

Sentences and Languages

• Sentences are strings of characters over an alphabet.
• Languages constitute sets of sentences.

Lexemes and Tokens

• Lexemes are the lowest syntactic languages unit
• A categories of lexemes from tokens.

Recognizing Languages

• Recognition devices read input language streams, and decide where inputs belong

Generators

• Devices generate language sentences

Formal methods of Describing Syntax

• The Backus-Naur Form

Production Rules and Grammar

• Production rules have LHS/RHS terminal, and nonterminal symbols.
• A grammar constitutes what
• Abstractions are the symbols with more that on RHS
• Using recursion the syntax lists create the terminal symbols

Derivations

• Derivations create terminal symbols
• Sentential form can derive from derivation
• Grammars have two parse tree and a sentential form
• One or more parse tree derivations lead to ambiguous grammars
• The precedence determines the non ambiguous statements.

Extended Backus-Naur Form (EBNF)

• Can show semantics along with parse trees

Grammar Attributes

• Grammar has no specification it's the compiler that creates a design

Semantics in Languages

Semantic interpretations can't be formal and no set "notation exists.

• Operational Semantics: changes memory of the hardware and software

Characteristics of Invariants

• Initial values must be present with the correct post conditions
• Proving invariants requires understanding of the machine

Denotations

• The language is defined by rigorous mathematics
• Each entity must be define.
• Variables are all related to one another.

BNF limitations

• The BNF will still require an attribute/ semantic data type
• No single notation is able to formalize the semantics

Data Types and Variables (Introduction and Primitives)

• Data types define objects, plus operations on objects.
• Descriptors are variable attributes collections
• An objects presents a data type.

Introduction to data types and variables with different number of primitive structures

• Many languages provide primitive data
• Only very little non-hardware support with data
• Numbers are exact, with 8 different variables
• Float: are approximations
• Complex: pair of floats with literal forms.
• Decimal types: business apps, fix memory and are essential for COBOL.

Character Boolean

• Boolean: the simplest.
• Character is stored as numeric coding is 16 bit code

Character String Types and certain languages

• String is sequenced
• String may be static and dynamic
• Typical strings: assignment and comparision
• Characters is not from C and C ++

More about characters and strings

• Many operations provide elaborate codes, the code is primitive
• A String has static and dynamic lengths
• The language is writeable

Summary of Implementation

• May require desriptive of a compile- time code descriptor

Cardinal (Ordinal and Enumerated Types)

• Cardinal types associate with positive codes in java,char and boolean
• Variable have defined ranges for readability
• Enumerated types don't need a code for color
• ADA C#, and Java have better integration

Suubranges

• Ordered sub sequences from an ordinal type
• Subrtange create variable clear in the coder

Array Design

• Arrays has a location that identify it.
• There are 3 common arrays that are statically and dynamically bound
• Static: no dynamic allocations Fixed stock is defined only once- time issues

Implement arrays with help from Java using C++, Perl, the. NET

Declaration of an array's attributes

• Arrays can also be initialized

Hetrogeneous Array

• Need not be of the same type with limited flexibility from Java and python

Indexing Operations

• Provide operators to perform calculations on the data types

Static array allocation vs Heap Dynamic array allocation

• Static allocation provides no dynamic access to to memory
• Different memory is needed

Array memory addresses

• Access functions calculate single array dimensions

Array and variables.

Records are hetrogenouos collections

• Record is fast with high access speeds versus a variable memory cell
• Dynamic subscript requires checking

Union Design

• Unions vary in types, with design issues that arise often

Unions-types

• Unions support many languages constructs
• Fortan offers no type variable
• Types show more union discriminant

ADA unions - Types

• Types are memory pointer indicators

Pointers & References

• Have addresses
• Memory manage dynamic variable

Drawbacks due to pointer arithmetic

• May face dangling object issues

Pointer management.

• Should not be used to design a language memory type.
• Invertible memory

Pointer representations

• Large computers use single codes Intel uses of segments offset

Pointer Problem

Costly problems in time and space

Storage representation

All cells are assigned code All pointers are set garbage collected using trace method

Other problems

Additional space makes the process nontrivial. All the indicators make this a cost overhead. Many cells are non-trivial

Naming Variables

• Names must be limited. Connectors provide the code and make case statements

Special variable usage and allocation

• Variables take memory space, and must be declared for compilation reasons.
• Each have attributes related memory issues. Aliases impact memory and make code difficult

Binding & Lifetime

• binding helps with memory location and is dynamic in certain types
• static- bound to memory cell -Dynamic, bound to memory in the execution.

Types & Variables

• All data except code are volatile
• Static scopes allow code during executions
• Stack codes creates codes for declaration

Arrays Types and variables

• dynamic, allocation and deallocation

Heap Dynanmic

• Memory allocations with statements
• Dynamic allocations help de alloctions create inefficient results.

Compile time vs detection

• Errors must always be found

Type and Variables

Types check correct operation

Variables

• Static binding

Variables and expressions

• Some expressions can run at the end.

Run Errors

-Some errors are found

Functions & Operators

• Some relational statement make more statement and values correct
• Operations cause to much error.
• It's difficult to test that correct the values are correct.

Code Operations.

• No standard syntax
• Run on machines

Expressions and Statements & Control Structure

Expressions can describe calculations of a Language

• Can be used when the statement has orders

Arithmetic & Design

• Expressions take parentheses for commands
• Precedence makes statements follow

Operations

• A unary operator needs one operator
• A binary operator needs two operator
• A ternary operator needs three

Precedaence rule statement

• Make level code with order in operation

Statement associativities

• make expressions with value
• Right goes left
• Expression rules take paranthesis to override

Side Effects.

Functions cannot change value

• Side results.

Advantages can be made to change the side states

• Operations must be in order

Value can change with code

Operations need many roles with some exceptions

• Operations may use a div or division, there is no standard.
• Overload can be set in Ada,C++ make many operations

Transferring codes

Make easy coercion between different value types

• Can narrow and change to widen or narrow and wide versa. Operations have many exceptions.

Conversion statement

• Can show different code operations

Statement Operators

• Different variables are evaluated with boolean results

Operator variables and statements

Different logic

• A and B will have different side paths Short statement loops make many operations from languages using CO3,

Short Statement.

• A single general variables

Statement assignment operations

• There can be single operations . A =/2+14

Operations and function uses

• Single general function variable: if ( a >b )11 B++/ +3. Can use c++

Expression variable

• A single general statement

Statement list assignment.

A=1+2*c+161; B=A+1

Mode Assignment

Statements may change value as 2+ C++

control function

Control is used in statements that check function call operations

flow in functions

Levels of expression are taken from programming units

statement evolutions

Control flow and loops can only be selected from test functions, they are generated. Two test can run logical loops.

statement selections

There are to two kind that help statements for code

Statement functions

If, statements, Selectors are read by different conditions The code will read Test, operation and final, for

Syntax

What is type with that read test with

Clause forms

To read if

multiple statement selections

• Select and see number command
• Read which segments

Code Structure

To check code segments from - switch to statement function

• There can be no function to read the segments
• Code can either be a string or have expression problems If it cannot recognize it

Code loop structure

• Redoes a command or combines statements and functions for the resolution -What command needs to be followed -Where can you find loop commands.

Counter-Loop Commands

A variable takes to a final and steps

• code types
• Loop value
• Code can loop but not affect reading All of operations must loop only once • ADA can choose the right command Each variable has a range of loops that's must run after it.

Loops in languages .

• The system code loops each operations

Loops In Code

Each loop takes many expressions A expression may need multiple loops.

Code with many loop functions.

Functions that the programmer sees each function. Many commands see each function that runs.

Control Operations.

• Each operations transfer command to a clear part. Functions may not support it