Untitled

• Principles of Programming Languages, prepared by Graeven Videz.

Why Study Programming Languages

• Studying programming languages allow programmers to solve problems in new creative ways, make their code more effective and flexible and increases their ability to learn and to choose new languages
• Understanding programming languages help future developer to understand which language to use for each new projects
• A deeper understanding of programming concepts can teach developers to write more efficient code, by using libraries, language-specific features, and more

Programming Domains

• Programs are developed to automate business processes, manage data, and generate reports for analysis in Business applications using libraries like pandas for data analysis
• Programming can build applications to handle complex mathematical calculations and simulations for various industries, such as Engineering and Accounting for Scientific Applications, using Python libraries such as NumPy and SciPy.
• Systems that can learn, reason, and make decisions are developed through programming for Artificial Intelligence, using libraries like TensorFlow and PyTorch.
• Systems programming places an emphasis on software that works with hardware to provide valuable services to Operating Systems, Networks by using C, Rust, Go
• Web software encompasses front-end, back-end, and full-stack development for web applications and websites, using Javascript and PHP.

Language Evaluation Criteria

• Readability is the ease with which programs can be read and understood by humans:
• Overall simplicity features few elements and constructs, limited use of similar features, and minimal use of complex operations.
• Orthogonality is the ability to change one element without affecting others, with basic building blocks that can be combined in different ways and most combinations of these blocks allowed.
• There are data types to provide sufficient predefined types for common tasks.
• Syntax considerations require flexible rules for naming variables and functions, clear ways to write complex statements, and keywords and a structure that are easy to understand and use.
• Python is the best contender for the most readable syntax with sentence-like structures
• Perl is known for its "write-only" nature, because its syntax is complex and uses many special characters.
• The C language provides a small set of constructs that can be combined in various ways, it is considered a flexible language.
• Assembly language lacks higher level constructs and requires detailed repetitive code construction, making it harder to understand
• Java offers a well-defined set of primitive data types with easy declaration methods, which makes the code predictable and easy to read.
• C++ allows more complex data types and has a method called operator overloading, which reduces clarity.
• Ruby has clear and meaningful keywords that make the code self-explanatory to non-programmers.
• APL uses a unique set of symbols and concise syntax, which can be challenging to read.
• Writability is the ease with which developers can use and write code using a programming language
• Simplicity and orthogonality feature few constructs, primitives, and clear combination rules.
• Support for abstraction involves defining and using complex structures or operations in ways that allow details to be ignored.
• Expressivity features convenient ways to specify operations, and numerous operators and predefined functions.
• Reliability highlights support features that helps fix the resources of the program
• Type checking is the process of verifying that the data in a program is of the expected type (i.e., catching data type mismatches).
• Exception handling is a mechanism for dealing with errors that occur during program execution, and try-catch blocks can be set in languages like Java, Python, and C++ to handle exceptions.
• Aliasing occurs when two or more variables refer to the same memory location, or when two variables attempt to use the same memory resource.
• Portability is the ease with which programs can be moved from one implementation to another
• Generality is the applicability to a wide range of applications
• Well-definedness is the completeness and precision of the language's official definition

Influences on Language Design

• Computer architecture: Languages are developed around the prevalent computer architecture, known as the Von Neumann architecture.
• The Fetch-execute cycle consists of initializing the program counter, then repeating fetching the instruction pointed to by the counter, incrementing the counter, decoding the instruction, and executing the instructions.
• Program design methodologies: New software development methodologies led to new programming paradigms, and new programming languages.
• 1950s-Early 1960s: Simple applications worried about machine efficiency.
• Late 1960s: Programmer efficiency became important, readability and better control structures were set in place, and structured programming and top-down design emerged.
• Late 1970s: Programming became more process-oriented and data-oriented, and data abstraction was developed.
• Mid-1980s: Object-oriented programming emerged, data abstraction was improved upon, and the practices of inheritance and polymorphism were put into practice.

Evolution of the Major Programming Languages

• Machine language (1940s): The earliest programming method written directly in binary 1s and 0s that are understood by computers.
• Assembly language (1950s): Offers a readable format compared to machine language, uses mnemonics and symbols for operations and memory addresses.
• FORTRAN (1957): Developed by IBM for scientific and engineering applications, marking the start of sophistication in programming languages and the first high-level language.
• LISP (1958): Stands for LISt Processing, was created for Al research and used symbolic expressions (S-Expressions) and recursion.
• COBOL (1959): Stands for Common Business Oriented Language, used to make the code easily readable, it was designed for used in business, finance and administrative systems.
• BASIC (1964): Beginner's All-purpose Symbolic Instruction Code, intended for teaching beginners.
• C (1972): Was designed for system programming and writing operating systems, and gave programmers direct control over hardware with a higher-level syntax.
• C++ (1983): Extended C by adding Object-Oriented Programming it was designed for high performance and flexibility, used for including software, games and operating systems.
• PYTHON (1991): Uses web development, scientific computing and data science.
• JAVA (1995): Was designed with portability and scalability in mind, running on any platform using the Java Virtual Machine (JVM), becoming widely used in enterprise software and Android development.
• PHP (1995): Hypertext Preprocessor, designed for server-side web development and embedding in HTML.
• SWIFT (2014): Created by Apple for iOS and related development, and was designed to be a safer, more modern alternative to C.

Language Categories

• Languages that support Object-Oriented Programming, scripting and visual languages, featuring variables,assignment statements, and iteration are classified as Imperative
• C, C++ Java, JavaScript, and Visual BASIC are imperative languages
• Step-by-step execution: Instructions are executed sequentially
• Variable manipulation: Programs directly modify the state of variables within the code
• Control flow structures: Loops, conditional statements, and functions are used to control the program's execution flow.
• Functional is based on mathematical functions and used to perform computation, its designed uses conditional expressions
• LISP, Scheme, Mdchine Language, and F# are functional
• Logic language used to instruct computers to make decisions
• Prolog, Datalog are Logic type Languages
• Markup/Programming Hybrid is Markup languages extended to support programming, combining the framework features of a markup language with the ability to execute programming languages
• JSP, JSTL are Markup/Programming Hybrid type Languages

Describing Syntax and Semantics

• Syntax: The form or structure of the expressions, statements, and program units
• Semantics: The meaning of the expressions, statements, and program units
• Syntax and Semantics provide a language's definition
• Sentence: A string of characters
• Language: A set of sentences
• Lexeme: the lowest level syntactic unit of a language
• Token: A category of lexemes, e.g., identifiers

Backus-Naur Form and Context-Free Grammars

• Backus-Naur Form (1959): invented by John Backus to describe the syntax of Algol 58, BNF is equivalent to context-free grammars and is a Notation used to describe the syntax of formal languages
• Context-Free Grammars: developed by Noam Chomsky in the mid 1950s and is Language generators, meant to describe the syntax of natural languages

Symbols In Backus-Naur Form

• Chevrons: Denote a non-terminal symbol where if a non-terminal symbol appears on the right side of the production rule, another production rule can replace it.
• Pipe Symbol/Vertical Bar: a metacharacter that is used to denote alternatives ("or").
• "::=": "is defined as"
• Quotations: Denote terminal symbols

Backus-Naur Form Definitions

• Terminal Symbols: the basic indivisible units, literal values, and "Hello World", "123", and "Juan Dela Cruz" are its values
• Non-Terminal Symbols: Placeholders that represent more complex structures, variables that need to be or can be expanded, such as , , and

Examples of Grammars For a Language

• Example of a simple language that expresses a greeting denoted by either "Hello" or "Hi"

<greeting> ::= "Hello"|"Hi"

• Light switch grammar in either "on" or "off"

<command> ::= “on” | “off”

• The definition of names:

<name> ::= <first-name> <last-name>
<first-name> ::= “Alice” | “Bob” | “Charlie”
<last-name> :: ::= “Smith” | “Jones” | “Williams”

• Derivation is the step by step progresses to apply BNF rules

 <name> ::= "Alice" "Smith"

• Recursion occurs when a non-terminal symbol is defined in terms of itself, lists, mathematical expressions, and sentences are good applications of recursion

<digit> ::= 0|1|2|3|4|5|6|7|8|9
<natural> ::= <digit>|<digit><natural> 

• Examples of Sentence Construction

 <sentence> ::=  "the" "dog" "eats" "the" "bird"