Fundamentals of Programming

Unit 1 Overview: Fundamentals of Programming

• Focuses on key concepts and historical context in the realm of programming languages
• Covers importance of studying programming languages, their history, and the impact and role of programming paradigms
• Explores programming environments along with the effect of machine architectures
• Introduces the programming paradigms such as procedural, object-oriented, functional, and logic-based approaches

Importance of Studying Programming Languages:

• Computers are fundamentally limited in their ability to understand natural languages, necessitating precise programming languages

Functional View of a Computer:

• Humans interact with computers through input/output (I/O) devices such as keyboards, mice, and monitors
• Input from these devices gets processed by the CPU
• The processed information can move to main or secondary memory for storage and retrieval
• The CPU sends necessary data to one or multiple output devices

Programming Languages Defined:

• A program involves an ordered sequence of instructions that guides the computer's actions
• These programs need a language that the computer can process easily
• Programming languages provide the means to express a program. Python, Java, C, and C++ are popular examples
• Programming languages consist of syntax which dictates the structure of a language, and semantics which defines the meaning

Reasons to Learn Programming Languages:

• Improves ability to develop effective algorithms
• Improves existing programming language use
• Increases vocabulary of programming constructs
• Provides a better language choice
• Simplifies learning new languages
• Simplifies designing new languages

The Importance of Expressive Power:

• The ability to think at a deeper level relies heavily on the capacity to express ideas through language
• It is difficult to conceptualize structures without the means to describe them, verbally or in writing

Existing Programming Language Usage:

• Many professional programmers possess limited formal education in computer science, restricted to a small set of languages
• Programmers often prefer to use familiar languages, potentially overlooking more suitable options for a task

Software Technologies are Constantly Evolving:

• Computer science is considered to be still maturing
• The constant evolution of software technologies includes design methodologies, software development, and programming languages
• Understanding programming language design and implementation enhances the ability to learn new languages

Understanding Language Implementation:

• Learning about language implementation enhances understanding of its design
• Addressing bugs often necessitates knowledge of implementation details

Language Selection:

• Certain programming languages perform better for particular tasks than others
  • FORTRAN and APL are suited to calculations
  • COBOL and RPG lend themselves to report generation
  • LISP and PROLOG are applied in AI
• Feature implementation knowledge improves existing programming language use

New Language Design:

• Designing new languages benefits from prior knowledge to ensure effectiveness, efficiency, and user convenience
• Previous knowledge and concepts often design new languages

History of Programming Languages:

• Focuses on the development of early languages, the evolution of software architecture, and various application domains

Programming Language Timeline:

• 1951-55: Initial use of expression compilers
• 1956-60: Development of FORTRAN, COBOL, LISP, and Algol 60
• 1961-65: Introduction of APL notation, Algol 60 (revised), SNOBOL, and CPL
• 1966-70: Evolution of APL, SNOBOL 4, FORTRAN 66, BASIC, SIMULA, Algol 68, Algol-W, and BCPL
• 1971-75: Release of Pascal, PL/1 (Standard), C, Scheme, and Prolog
• 1976-80: Creation of Smalltalk, Ada, FORTRAN 77, ML, and C++
• 1981-85: Emergence of Smalltalk-80, Prolog, and Ada 83
• 1986-90: Development of SML and Haskell
• 1991-95: Update to Ada 95, and introduction of TCL and Perl
• 1996-2000: Advent of Java
• 2000-05: Launch of C#, Python, Ruby, and Scala

Development of Early Languages:

• Numerically based languages
  • FORTRAN, Algol, Pascal, PL/1, BASIC, C, and C++ serve to handle computing mathematical expressions
• Business languages
  • COBOL is based on common business, with English-like notation
• Artificial Intelligence(AI) languages
  • LISP(LISt Processing) and PROLOG(PROgramming in LOGic use tree search and rule-based paradigms
• System Languages: C, C++
• Script Languages: AWK, Perl, TCL/TK
• Web Programming: HTML, XML, Java, MIcrosoft .NET family

Evolution of Software Architecture:

• Includes the stages of Mainframe Era, Personal Computer era, and Networking Era

Mainframe Era:

• Characterized by batch processing and interactive processing (time sharing)
• Language design focuses on file I/O in batch processing, error handling, and time constraints in interactive processing

Personal Computer:

• Features interactive processing and embedded system environments
• Language design involves no time sharing, good interactive graphics, and non-standard I/O devices

Networking Era:

• Uses a client-server model of computing
  • Servers provide information
  • Clients request information
• Language design involves interaction between the programs on client-server and active web pages

Application Domains:

• Focus on business processing, scientific applications, system-level programming, AI, publishing, and processes

Factors Influencing Programming Language Design:

• Computer capabilities
• Applications or scientific and internet uses
• Programming method
• Implementation methods
• Theoretical studies
• Standardization

Qualities of a Good Language:

• Clarity, simplicity, and unity
• Orthogonality
• Naturalness
• Support for abstraction
• Programming environment
• Ease of program verification
• Reusability
• Reliability
• Efficiency
• Well documented

Clarity, Simplicity, and Unity:

• A programming language should provide a framework for algorithm planning with expressing them
• It is to have a clear, simple, and unified set of concepts for developing algorithms

Orthogonality:

• Important language feature ensuring that changing one attribute doesn't affect others
• Features easier to learn and programs are write with exceptions and special cases to be remembered.

Naturalness for the Application:

• Languages provide appropriate data structures, operations, control structures, and natural syntax

Support for Abstraction:

• Abstraction is a substantial gap between the abstract data structure and operations that solve a problem by language

Programming Environment:

• An appropriate environment increases the utility and use of a language
• This is accomplished by providing reliable, efficient, and well-documented speeding up of creation and testing via testing packages
• Also must be able to maintain and modify multiple versions of program software

Program verifiability & Reusability:

• Reusability of a program is a major concern, and must be checkable by various techniques:
  • Formal verification
  • Desk checking and input output test checking.
• Simple semantics and syntactics are important in simplifying program verification

Syntax and Semantics:

• Syntax: what the programming language like
• Semantics: meaning given to the variety syntax constructor

Programming Paradigms:

• Involve specific approaches to solve programming problems
• Include imperative/procedural, object-oriented, functional, and logic programming

Imperative/Procedural Paradigm:

• Command-driven and state-oriented
• Programs consist of statement sequences that are executed
• Program consists of statement sequences that are executed
• Each instruction causes the computer to change values, which results in a new state

Declarative vs. Imperative Style:

• Imperative programming involves telling the computer how to do something
• Declarative programming defines what result you want, and the computer figures out how to accomplish it

Object-Oriented Programming:

• Uses objects with data fields and behaviors
• A computer program uses interacting objects
• Uses classes and objects and applies inheritance, encapsulation, and polymorphism

Logical Programming:

• Method of programming uses facts and a relationship between facts to get a result or output

Functional programming:

• Functional programming centers around functions and their valuations rather than explicit commands, which can implement recursion
• Some functional programming languages are Lisp, ML, Haskell, H# and Erland

How Programming Paradigms Impact programs:

• A programmed is solved by programmers in a specific way for solution requirements.
• Design errors are minimal, and there are are a variety of methods to manage complexity

Programming Environment:

• A developed and tested environment with the software for developers write, test, and debug programs
• Types of Environments:
  • Command -Line Environment uses a terminal/console like Bash as an example uses the GCC compiler for C programs
• IDE( Integrated Development Environment, that combines a code editor, debugger, and combine to make on compiler tool, such as:
  • Visual Studio
  • Eclipse
  • Pycharm
• Cloud Based Development Environments, run in a browser and use Github Codespaces
• Mobile And Embedded Development, are built for specific hardware:
  • Android Studio for Android Apps

Programming Environment Effects:

• Desirable to have various programmers and testing groups The language structure important so that programs are seperatley compiled.
• Compilers may need data about multiple Subprograms including number order, variables ,and data type

Translators

• Translator design allows programs to be translated from high-level languages to a the machines language
• These languages can use simulated programs and/or code running on a host system so those can be constructed in hardware -The goal is to translate programs in the high level code that have equivalent machine languages

Operation of a Computer:

• Computer operation relies on interactions between hardware and software
• Key hardware components:
  • CPU executes program instructions
  • RAM temporarily stores data
  • Storage devices provide long-term data storage
  • I/O devices enable human interaction
• The operating system manages these resources
• The execution cycle involves fetching, decoding, executing, and storing instructions

The Operation of a Computer - Data types:

Computers use six major component data types when associated with programming:

• Data is provided so that the computer may understand the data structure to be manipulated.
• Primitive operations are provided to so that the data may be manipulated.
• Sequence control manages how the primitive functions are to be executed.
• Data access is provided to control how the data is accessed by operations.
• Storage management so that a program may allocate storage for programs and data.
• And Operating system manages the communication structure for external date to be processed.

Virtual Computers

• Involves representing data structures and algorithms through hardware, firmware, or software (virtual machines)

Hardware Realization

• Involves creating representing data and algorithms directly through physical devices

Translators and Interpreters:

• Languages are split into two major divisions
  • Compiled the code is translated so it can run as a program by languages like C or C++
  • Interpreted languages doesn't use machine code, but still produces intermediate forms of the program so it is easy to run

Virtual Computers and Language Implementations:

• Language implementation has varying definition depending on the computer. Implementors tend to use differing virtual use based on computer definition.
• Same language had has differing data structures and operational information -Virtual conception has differing factors, implementation, choices on how to simulate.

Bindings and attributes:

• Names are the primary abstraction used, so that entities may denote names and Meanings captured
  • Attributes are names captured by entities for a variety of items such as
  • Location, Values, and Formal parameter types

Static vs Dynamic Binding

• Static can be determined at the translation/compilation time
• Dynamic attribute can be determined while being executed at run time

Low-Level vs. High-Level Programming Languages:

• Machine and assembly languages are low-level
  • Machine language uses binary code (0s and 1s), is CPU-specific, fast, and requires no translation, but lacks portability
  • Assembly language uses mnemonics and maintains the same properties as machine language
• High-level languages(HLL) such asC, C++, Java, FORTRAN, Visual Basic, and Delphi are more programmer-friendly and portable

HLL's

• Have to be translated and use built-in primitives/grammatical