• Some computer scientists thought that a SINGLE, UNIVERSAL, MACHINE-INDEPENDENT PROGRAMMING language would be useful
• Tired of rewriting all their programs whenever they got a new computer
• would like a language suitable for discussing algorithms, such as in CS journals

• The Algol-60 report is a paradigm of brevity and clarity
• The original algol-60 report was 15 PAGES LONG
• used BNF for the syntax--clear, precise, unambiguous english-language description for the semantics
• remains the "gold standard" against which to compare programming language descriptions

1. The reference language
2. the publication language
3. hardware representation

They were different in lexical conventions but had similar syntax; disagreement over the use of a period of a comma to represent a decimal place led to this decision

• Algol has n-dimensional arrays, and FORTRAN only has arrays up to 3 dimensions
• Another difference is in their lower bounds -- the lower bound of FORTRAN IV's arrays is always 1, while Algol-60 allows an array's lower bound to be an integer other than 1
• FORTRAN IV restricted the allowable expressions for array indices/ subscripts to one of 5 specific forms, while Algol-60 permits any integer expression to serve as an array index/subscript

*choice of parameter-passing modes;

*provided 2 parameter-passing modes, (if none is specified, the default is used, and one can specify an alternate means if desired;)

*the default is pass-by-name

*you can explicitly request pass-by-value

• ~a compound statement uses the begin and end of keywords and allows a sequence of statements for where only one would exist (begin … end in a for loop)

• ~a block uses begin … end as well but the difference is that blocks contain declarations while compound statements do not

• a dangling else problem is where you are uncertain as to where an else attaches to.
  • algol addressed this problem by requiring a begin … end for every consequent if

*What is a Regular Expression (RE)?

What can these be used for?

~ a regular expression is used to describe tokens of programming languages

    ~ regular expressions can be used to identify a certain string of interest

•   ~ a finite set of symbols; ex: S = {cat} – in this case, cat is the alphabet

*What is a Context-Free Grammar (CFG)?

*What can these be used for?

• ~ a finite set of VARIABLES (also nonterminals or synctactic categories; each of these represents a language

• this can be used to describe features that have a recursive structure

(EX: S -> 0A1)

~ a terminal are the primitive symbols that represent the language (0 is a terminal in ex above)

*Given a CFG G, what does L(G) mean?

    -->the languages describable by BNF are exactly the Chomsky Type 2, context-free languages;

*When is a grammar said to be ambiguous? How can you prove that a grammar is ambiguous?

*What is a leftmost derivation? What is a rightmost derivation?

*Why was PL/I developed?

why is called a classic example of the "Swiss Army Knife" approach to language design?

why was it not more successful?

why did some consider PL/I to be a "fatal disease"?

how (one might argue) did it help lead to the development of Pascal?

• PL/I was developed because programmers had hoped there would be something for everyone in the language
• It was considered the "swiss army" knife of all programming languages because of all the languages attached to it
• It was considered a "fatal disease" because all the languages that became a part of PL/I all in all, made PL/I the union of all the languages that encompassed it, rather than the intersection

~ Wirth wanted non-numeric data to be handled

    ~ wanted to maintain maintain the compile-time and run-time efficiency of FORTRAN

    1. The language should be suitable for teaching programming in a systematic way.

    2. The implementation of the language should be reliable and efficient at compile-time and run-time on available compilers.

    ~ the goals were met and the language had a paper and became an international standard in 1982.

*How can enumeration types improve security and efficiency?

what are some of the benefits of enumerated types?

should be comfortable with the declaration, operations, and use of enumeration types in Pascal; you may need to read, write code using these types.

~improved security because: you can find inappropriate-use errors earlier

    ~ efficient because: you know how "HOW MANY, compute the minimum number of bits to assign consecutive integer codes; (DayOfWeek only needs 3 bits to represent its 7 different values ...)"

    ~ pascal addressed the problem by making an else go with the preceding if

 -->by assuming that each else is paired with the nearest unmatched then.

*How do Pascal's and Algol's for-loops compare? what additional iteration control structures does Pascal include?

    ~ pascal for loop syntax: for {name} := <expression> {to | downto} <expression> do <statement>

*From what area of research/work did Prolog arise?

   ~ a prolog fact is a set of rules in which something is true

      ~a query can use these facts of predicates

      ~a predicate is pretty much prolog’s equivalent of an if statement

    -->rules are Horn Clauses  

        Horn Clause: in logic:            

                     c : consequent - an atomic formula in predicate logic

        h's: antecedents

        c <- h1 ^ h2 ^ h3 ^ ... hn

        in prolog it looks like c :- h1, h2, h3, ... hn.

-->a Horn clause with NO TAIL is a fact;

--> Horn clause with a Tail is a Prolog rule;

  -->a varaible that is ONLY on the RHS of the :-

        is an AUXILIARY VARIABLE; it is bound

        in the course of proving, BUT its

        binding is not reported to the user;

the scope of a variable is one rule;

        and Prolog does not mind binding two different variables

        to the same value...

*What goes in a Prolog knowledge base? How do you load that knowledge base in SWI-Prolog?

~to tell the Prolog system that it has picked the "correct" rule for a particular goal;

~to tell the Prolog system to fail a particular goal immediately, without trying for alternative solutions;

~when we want to terminate the generation of alternative solutions through backtracking;

~ not can be written as \+ ( ), not()

~ and is written as commas in prolog

~ or is the predicate on the next line after a “.” of the previous predicate.

*What does the protocol predicate cause to happen, in a SWI-Prolog session?

~ the procol predicate causes prolog to log anything typed and outputted into the file specified (protocol(“file_output”).)

~ this is used with the variable on the left side, is in the middle, and the rest on the right side. The effect is that the right side is evaluated and is then what X becomes, whereas using the equal sign will not evaluate X if it were arithemetic

*You should be able to name at least one programming language which has significant support for programming in that paradigm (keeping in mind that some languages have support for multiple such paradigms)