Section 1
Preview this deck
logic
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 14, 2020
Cards (81)
Section 1
(50 cards)
logic
program statements described as facts computer's job is to construct a proof based on the given axion prolog
Backing of a powerful sponsor
COBOL (1959) -> IBM PL/1 (1964) -> IBM Ada (1980) -> Dod C# (2000) -> Microsoft
middle 1980s PM influences
object oriented programming data abstraction/inheritance/polymorphism
language categories
1. imperative 2. functional 3. logic 4. markup/programming hybrid
Why so many PL
languages designed for specific problem domain; personal preference; diverse ideas about best language to use
language evaluation criteria
1. writability: ease w which a language can be used to create programs 2. readability: ease w which programs can be read and understood 3. reliability: programs conform to their specifications under all conditions 4. cost: the ultimate total cost
imperative
central features = variables, assignment statements, and iteration (things that map directly to hardware) languages that support OO programming and scripting languages C, C++, Java, .NET, perl, javascript
FORTRAN I Features
post-test counting loop (do loop) three way selection statement (arithmetic if (expr) neg, pos, zero) user defined subprograms names have up to 6 characters no data typing statements (type dep on first let of variable name)
What makes a language successful
1. ease of use for novice 2. expressive power 3. ease of implementation 4. wide dissemination at minimal cost 5. excellent compilers 6. possibility to compile very good/fast code 7. backing of a powerful sponsor
two main influences on language design
1. computer architecture 2. programming methodologies
computer architecture
Languages are developed around the prevalent computer architecture, known as the von Neumann architecture
imperative language
most dominant because of von neumann computers
FORTRAN 90
free formatting of code, modules, dynamic arrays, array subsection references, case-statement, pointers, recursion, parameter type checking
functional
main means of making computations is by applying functions to given parameters in its purest form defined as mathematical functions, there is no concept of memory, time, or state LISP, Scheme, haskell
FORTRAN evaluation
highly optimized compilers (types/storage of all variables fixed before runtime) dramatically changed forever the way computers are used
ALGOL differences/generalizations from FORTRAN
assignment operator was := subscripts placed in brackets identifier names could be any length arrays could have any number of dimensions
why study PL
1. improve knowledge/understanding of languages you know 2. improve choice of language for applications 3. improve ability to learn new languages 4. choose among alternative ways to express an idea 5. make it easier to design new languages
FORTRAN IV
1960-2, explicit type declarations, logical if statement, subprogram names could be parameters
expressive power languages
APL (1967), Algol-68 (1968), C(1972), common lisp (1984)
language design tradeoffs
1. reliability vs cost of execution 2. writability (flexibility) vs reliability 3. readability vs writability
ALGOL 60 evaluation
Success! All subsequent imperative languages based on it. first machine-independent language. first language whose syntax was formally defined. standard way to publish algorithms for over 20 years failures: never widely used (esp in US), lack of I/O def made programs non-portable, too flexible, lack of support from IBM
excellent compilers; possible to compile very good (fast/small) code
fortran (1957)
reliability
1. type checking - testing for type errors (compile/runtime) - preventing a bit-pattern one type of data from being interpreted as a different type of data 2. exception handling - intercept run-time errors and take corrective measures 3. aliasing - presence of 2+ distinct referencing methods for the same memory location 4. readability and writability -a language that does not support "natural" ways of expressing an algorithm will require "unnatural" approaches
basis for imperative languages
-variables model memory cells -assignment statements model piping -efficient iterative form of repetition
FORTRAN II
1958, independent compilation
non-DSLs
C, C++, COBOL, Fortran not small, VERY expressive, not restricted to specific domains
Other evaluation criteria
1. portability: ease w which programs can be moved from one implementation to the other 2. generality: applicability to a wide range of applications 3. well-definedness: the completeness and precision of the languages official definition
programming methodologies
new software development methodologies (eg object-oriented software development) led to new programming paradigms and by extension, new programming languages
Markup/programming hybrid
Markup languages extended to support some programming Examples: JSTL, XSLT, XML, HTML
ease of use for novice languages
BASIC (1964), Logo (1967), Scheme (1970), Python (1991)
1950s-1960s PM influences
simple applications: worry about machine efficiency
ALGOL design features
concept of data type formalized compound statements (begin...end) if statement has else-if clause parameters separated by mode (passed in/passed out)
ALGOL 60
modified algol 58 at 6 day meeting in paris new features: - subprogram recursion (new for imperative languages) -two parameter passing methods (pass-by-value and pass-by-name) -block structure (lexical scope); nested functions -stack storage allocation
readability
1. simplicity and orthogonality - relatively small set of primitive constants - consistent set of rules for combining them - every possible combination is legal and meaningful -minimal feature multiplicity -minimal operator overloading 2. data types and structures -adequate predefined data types and structures 3. syntax considerations - self-descriptive constructs, meaningful keywords, methods of forming compound statements
ALGOL environment of development
FORTRAN had barely arrived many other languages being dev for spec machines no portable language (all machine dependent) ALGOL = result of efforts to define a universal language
DSLs
cascading style sheets (CSS) structured query language (SQL) unified modeling language (UML) programming can be done by a domain expert (not a seasoned programmer)
FORTRAN outcome
-programs larger than 400 lines rarely compiled -code was very fast -quickly became widely used
ALGOL design process/goals
joint european-american committee met in 1958 goals of language: 1. close to mathematical notation 2. good for describing algorithms 3. must be mechanically translatable to machine code Not intended to be implemented Dropped by IBM-- thought to be too expensive to adopt a new language
ease of implementation; wide dissemination at minimal cost
BASIC (1964), pascal (1970), java (1995)
von neaumann architecture
-memory separate from CPU -data and programs both stored in memory -instructions/data piped from memory to CPU -basis for imperative languages
late 1960s PM influences
people efficiency became important, structured programming: top-down design and step-wise refinement
FORTRAN environment of development
-computers had small memories and were unreliable -applications were scientific -no programming methodologies or tools -machine efficiency was most important concern
writability
1. simplicity and orthogonality - relatively small set of primitive constants - consistent set of rules for combining them - every possible combination is legal and meaningful 2. support for abstraction - ability to define and use complex structures or operations in ways that allow details to be ignored 3. expressivity - a set of relatively convenient ways of specifying operations - strength and number of operators and predefined functions
late 1970s PM influences
process oriented to data oriented; data abstraction
FORTRAN 77
character string handling, logical loop control statement, if-then-else statement
PL/I environment of development
1964: IBM's POV -scientific computing: IBM 1620, 7090 comps, FORTRAN, SHARE user group -business computing: IBM 1401, 7080 comps, COBOL, GUIDE user group by 1963: scientific users need more elaborate I/O business users need FP and arrays
Domain-specific language (DSL) definition
a language specifically designed to perform tasks in a certain domain
implementation methods
1. compilation: programs are translated to machine language (slow transl, fast exe) 2. pure interpretation: programs are interpreted/executed in a stepwise fashion by the interpreter (immediate exe, slower, requires more space) 3. hybrid systems: a compromise between compilers and pure interpreters
cost
more important: -closeness in purpose to application (writing programs) -reliability (poor reliability --> higher cost) -maintaining programs less important: -compiling programs -executing programs (speed, space, etc) -language implementation system (availability/cost of compilers, IDE)
Programming domains w/ corresponding languages
1. scientific apps - large # of FP comps, use of arrays -FORTRAN 2. business apps -produce reports using decimal #s / chars -COBOL 3. AI -manipulate symbols rather than numbers, use of linked lists -LISP 4. systems programming -efficiency, low-level access, pointers -C 5. Web software -Markup (xhtml) -general purpose (java, ruby, kotlin) -scripting (javascript, php)
Section 2
(31 cards)