The document discusses the importance of studying programming languages, highlighting their applications across various domains such as scientific, business, and artificial intelligence. It explores different programming categories, including imperative, object-oriented, logic, functional, and markup languages, along with their design trade-offs and implementation methods. Additionally, it covers programming environments and tools available for software development, emphasizing the evolving nature of these tools and their integration capabilities.

1. Preliminary Concepts
Unit - 01

2. 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 significance of implementation
• Better use of languages that are already known
• Ability to design new languages
• Overall advancement of computing

3. Programming Domains
• Scientific Applications
• Simple data structure but requires large number of floating point computation
• FORTRAN (Later ALGOL)
• Common data structures Arrays, Matrices
• Common control structures Counting loops, selections
• Business Applications
• Produce reports, use decimal numbers and characters
• COBOL
• PCs introduced in Businesses
• Spreadsheets and Database systems were developed

4. • Artificial Intelligence
• Symbols rather than numbers manipulated
• LISP
• Later PROLOG logic programs were invented
• Systems Programming
• OS and programming support tools System S/W
• Low level features
• Programs  Assembly language / Specific language of system programming
• C
• Web Software
• Represent dynamic content, audio, video etc..,
• Supported by collection of languages: markup (e.g., XHTML), scripting (e.g., PHP),
general-purpose (e.g., Java)

5. Language Evaluation Criteria
• Readability
Overall simplicity
Orthogonality
Control statements
Data types and structures
• Writability
Simplicity and Orthogonality
Support for abstraction
Expressivity

6. • Reliability
Type checking
Exception handling
Readability and Writability
• Cost
• Others
Portability
Generality

7. Influences on Language Design
 Computer Architecture :
 Well-known computer architecture: Von Neumann
 Proposed by John Von Neumann(1945)
 Consists ; CPU , Memory and I/P – O/P devices
 Language  Imperative/ Procedural
 Data and programs stored in the same memory
 Memory is separate from the CPU
 Instructions and data are piped from memory to the
CPU
 The results of operations in the CPU must be moved
back to memory
 Basis for imperative languages
• Variables model memory cells
• Assignment statements model piping
• Iteration is efficient

8. Programming Methodologies :
 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

9. Language Categories
Imperative /Procedure-Oriented Programming :
 statements Oriented or command-driven
 Designed based on Von-Neumann Architecture.
 Each series of steps is called a procedure
 Central features are variables, assignment statements, and iteration
 Fast Compilation & Execution
 Requires less Memory Space
 Examples: C, Pascal, ALGOL, Fortran, BASIC
 No access specifiers
 Data not so secured

10. Object-oriented Programming:
 Everything is considered as an Object.
 Treats a program as a group of objects composed of data and program elements,
known as attributes and methods.
 Objects can be reused within a program or in other programs.
 Code is easier to reuse and scale.
 Low cost of development
 Data Security, Data can be extended
 Features  Data abstraction, inheritance, Encapsulation, Polymorphism
 Examples: Java, C++, Python, Ruby

11. Logic Programming:
 Rule-based (rules are specified in no particular order)
 Expresses a series of facts and rules to instruct the computer on how to make
decisions.
 Example: Prolog, Absys, Datalog
Functional Programming:
 Focus on the output of mathematical functions and evaluations.
 The main means of making computations is by applying functions to given
parameters
 Each function–a reusable code module–performs a specific task & returns a result.
 The result will vary depending on what data you input into the function.
 Examples: LISP, Scala, Erlang, F#

12. Markup
• These are not programming languages
• Extended to support some programming languages
• Used to specify the layout of information in Web documents
• Examples: XHTML, XML, HTML

13. Language Design Trade-Offs
Reliability vs. cost (of execution)
• Conflicting criteria
• Ex: Java demands all references to array elements be checked for proper indexing but
that leads to increased execution costs
• And C doesn’t require index range checking
• C programs execute faster than Java
• Java programs are more reliable
• Designers of Java traded execution efficiency for reliability
Readability vs. Writability
• Another conflicting criteria
• Example: APL provides many powerful operators (and a large number of new symbols),
allowing complex computations to be written in a compact program but at the cost of
poor readability

14. Writability (flexibility) vs. reliability
• Another conflicting criteria which is common in language design.
• Ex: C++ pointers are powerful and very flexible but they have reliability problems
with pointers ,they are not included in java
Implementation Methods:
• Primary Components of Computer  Internal Memory + Processor( Microinstructions)
• Language implementation system  OS
• Absence of supporting s/w  Own machine language (inflexible)
• Types of methods
• Compilation/ Compiler Implementation
• Pure Interpretation
• Hybrid Implementation System

15. Compilation
• Translate high-level programs (source
language) into machine code (machine
language), which can be executed
directly on the computer
• Slow translation, fast execution
• Ex: C, COBOL, C++
• Use: Large Commercial Applications

16. Compilation Process
Lexical analysis:
• Converts characters in the source program lexical
units
• Ignores comments in the source program because the
compiler has no use for them.
Syntax analysis:
• Transforms lexical parse tree  represent the
syntactic structure of the program
• In many cases, no actual parse tree structure is
constructed; rather, the information that would be
required to build a tree is generated and used directly.
Semantics analysis:
• Generate a program in a different language, at an
intermediate level
• Optimization improves programs (usually in their
intermediate code version) by making them smaller
or faster or both

17. Code generation:
• Translates the optimized intermediate code version of the program equivalent machine
language program.
• The symbol table serves as a database for the compilation process
• The primary contents of the symbol table are the type and attribute info of each user- defined
name in the program.
• This info is placed in the symbol table by the lexical and syntax analyzers and is used by the
semantic analyzer and the code generator.
• Additional Compilation Terminologies
• Load module (executable image): the user and system code together
• Linking and loading: the process of collecting system program and linking them to user
program(Linking)
• Linker: a systems program used in linking and loading process

18. Von Neumann Bottleneck
• The speed of the connection between a computer’s memory and its processor often
determines the speed of the computer
• Because instructions often can be executed much faster than they can be moved to the
processor for execution.
• The connection speed thus results in a bottleneck
• It is the primary limiting factor in the speed of computers

19. Pure Interpretation
Programs are interpreted by another program 
Interpreter
No translation
Easier implementation of programs (run-time errors can
easily and immediately displayed)
Slower execution (10 to 100 times slower than
compiled programs)
Often requires more space
Becoming rare in high-level languages
Significantly come back with some latest web scripting
languages (e.g., JavaScript, PHP)

20. Hybrid Implementation Systems
• A compromise between compilers and pure
interpreters
• A high-level language program is translated to an
intermediate language allows easy interpretation
• Faster than pure interpretation
• Examples –
• Perl programs partially compiled to detect errors
before interpretation
• Initial implementations of Java were hybrid
• the intermediate form, byte code, provides
portability to any machine that has a byte code
interpreter and a runtime system (together, these
are called Java Virtual Machine)

21. Programming Environments:
 P E The collection of tools used in the development of software.
Collection  only a file system, a text editor, a linker, a compiler.
 a large collection of integrated tools (uniform user interface)
EX : UNIX
• Older programming environment (middle 1970s), built around a portable multiprogramming
operating system.
• Provides a wide array of powerful support tools for software production & maintenance in a
variety of languages.
• In the past, the most important feature absent from UNIX uniform interface more difficult to
learn and to use.
• Now often used through a GUI that runs on UNIX.
• Ex of UNIX GUIs: Solaris Common Desktop Environment (CDE), GNOME, and KDE.
• These GUIs make the interface to UNIX appear similar to that of Windows and Macintosh
systems.

22. Borland JBuilder :
• Programming environment that provides an integrated compiler, editor, debugger, and file
system for Java development  accessed through a graphical interface.
• JBuilder is a complex & powerful system for creating Java software.
Microsoft Visual Studio .NET:
• It is a large & elaborate collection of software development tools, all used through 
windowed interface.
• Used to develop software in any one of the five .NET languages: C#, Visual Basic.NET,
JScript (Microsoft’s version of JavaScript), F# (a functional language), and C++/CLI.
NetBeans
• Development environment primarily used for Java application development but also
supports JavaScript, Ruby, and PHP.
• Visual Studio & NetBeans  also frameworks (common parts of the code )