1. Programming Languages
Meeting 14
December 6/7, 2016

2. CATS

3. Planning Final Exam, next week
Wednesday, December 14, 6:15 – 8:45 pm, MSC G90, our regular classroom
Or Thursday, December 15, 2:30 – 5:00 pm, MSC G90, our regular classroom

4. Topics for Final Syntax and syntax specification: EBNF Abstract syntax
Nonterminal, terminal, production, start symbol
Grammar of expressions
Inferred precedence and association
Syntax trees
Examples: Pam, REF, expressions, dates, AWK, …
Abstract syntax

5. Topics (1.1) Semantics and semantic specification
Env, Loc, Store, Value, Memory
Denotational semantics
Program functions
Backus notation for functional programming

6. Topics (2) Semantics examples Control structures
REF, a language of pointers
Multiple assignment statements
Control structures
Sequence
While
If-then
For

7. Topics (3) Parameter passing Value Result Value-result Reference Name
Reserved variable

8. Topics (4) Functional programming Lists Atoms Primitive functions
Functionals
User-defined functions
Predicates

9. Topics (4.1) Developing from primitives and functionals
Use of recursion
Catching error conditions
Proper error messages
Measures of lists
Length
Depth

10. Topics (5)
Scripting languages
AWK
Perl
Regular expressions

11. AWK Questions

12. AWK Exercises
Write an AWK program that takes a text file and creates a frequency count for each of the words in the file.
{for (w=1;w<=NF;w++) count[$w]++}
END {for (w in count) print count[w],w}

13. AWK Programs
What do each of these programs do? /^$/ {count++} END {print count} /<..*>/

14. AWK Exercises
Given a file of words, one per line, write an AWK script that returns the frequency count of the letters in the words. Use a template that
has one action statement in body, a for loop
has one statement for the END pattern, a for loop that controls the printing
uses one user-defined variable, an array called lc
uses the substring function, substr, to split each word into its individual characters.

15. PERL Practical Extraction and Support Language
A glue language under Unix
Written by Larry Wall
See

16. PERL Scripting language More powerful than AWK
More flexible than shell scripts
Syntax derived from C
Large language
Later versions contain classes
Many irregularities in design
Many alternatives for syntax

17. PERL Beginning assumptions and notations
Statements are terminated by ; (semicolon)
Comments start with # and occupy the rest of the line.
NO two-line comments
Parentheses around arguments to built-in functions are optional

18. PERL
First line of program is an interpreter directive, written as a special type of comment, giving the full path to the Perl interpreter
#!/usr/local/bin/perl -w

19. Example 1
#!/usr/local/bin/perl –w print(“Hello, world!\n”);

20. Example 1 #!/usr/local/bin/perl –w print(“Hello, world!\n”);
Inserts new line character

21. PERL Scalars Arrays Integer, real, string Indexed by integers
Identifier must start with $
Arrays
Indexed by integers
Identifier must start
Indexed by strings
Identifier must start with %

22. Example 2 #!/usr/local/bin/perl –w print(“What is your name? ”);
$name = <STDIN>;
chomp($name);
print “Hello, $name!\n”;

23. Example 2 #!/usr/local/bin/perl –w print(“What is your name? ”);
$name = <STDIN>;
chomp($name);
print “Hello, $name!\n”;
Critical space

24. Example 2 #!/usr/local/bin/perl –w print(“What is your name? ”);
$name = <STDIN>; #Reads one line
chomp($name); #Cuts off EOL
print “Hello, $name!\n”;

25. PERL
Control structures
if-then-elsif
foreach $element (%list) { … }

26. Example 3 #!/usr/local/bin/perl –w print “What is your name? ”;
$name = <STDIN>;
chomp($name);
if ($name eq “Nico”)
{print “Hello, $name! Glad you’re here.\n”}
elsif ($name eq “Daphne”)
{print “Going outside, $name?\n”}
else
{print “Hello, $name.\n”};

27. PERL Dynamically typed Numbers, strings, regular expressions
Type inferred from operations
Compare
2 < 10 (true)
2 lt 10 (false)
2 < “10” (true)
“2” lt 10 (false)
Numbers, strings, regular expressions
Operators are not overloaded

28. Arrays of Strings @words = qw(camel llama alpaca);
Can be initialized with a list of strings
@words = (”camel”,”llama”,”alpaca”);
Or use the keystroke saving function qw
@words = qw(camel llama alpaca);
Note that an individual element is a string so that the string identifier syntax must be used
$words[0] has value camel

29. Array Bounds Out of bounds arrays
Impossible with associative arrays: strings are not presumed to have order (in the sense of a next function)
Impossible with integer indexed arrays
@a = (2,3,5,7);
$a[7] = 17;
We’ll check the Env and Store

30. Scalar Operators Numeric: + - * / ** %
Numeric comparison: < <= == >= > !=
String: . (for concat)
x (for multiple concat)
String comparison: lt le eq ge gt ne
Assignment:
= (carries value of expression)
binary assignment: += *= .= etc
increment: ++$i $i++
(increment then assign vs. assign then increment)

31. Examples
Watch the values of $a, $b, $c, $d $a = 17; $b = $a + 3; $b = $b * 2; $b *= 2; $b = 4 + ($a = 3); $d = ($c = 5); $d = $c = 5; $a += 1; ++$a;

32. Examples (2) Watch the values of $s, $t, $x, $y $x = 14; $x = $x – 1;
$s = “llama ”;
$t = $s x 3;
$t .= “moose ”;

33. Parameter Passing Parameter passing Formal parameters not included
Values of arguments to a function come in the array @_
Example, the call range(1,74,3) puts 1 in $_[0], 74 in $_[1], and 3 in $_[2]
Thus, a function can have a varying number of arguments.

34. Parameter Passing (2)
If parameter values are passed to a procedure (subroutine in PERL language) in an array local to the procedure, how are values returned to the calling program?
Options
Return statement
Last expression evaluated
Global variable

35. Examples
sub say_hello { print “hello, world\n”; } Invoked by say_hello();

36. Examples (2)
sub say_what { print “hello, $what\n”; } Invoked by $what = “everyone”; say_what();

37. Examples (3)
sub say_hello_to { print “hello, $_[0]\n”; } Invoked by say_hello_to(“everyone”);

38. Examples (4)
sub say { print “$_[0], $_[1]\n”; } Invoked by say (“Good”, “morning”);

39. Examples (5) sub say_lots { foreach $_ (@_) { print “$_ “;}
print “\n”; }
Invoked by
say_lots (“Good”, “morning”, “class”);

40. Thanks for being a class that has had fun while learning.

41. Paradigms
Programming paradigm: pattern of problem-solving thought that underlies a particular genre of programs and languages.
Four main programming paradigms:
Imperative
Object-oriented
Functional
Logic (declarative)

42. Imperative Follows the classic von Neumann-Eckert model:
Program and data are indistinguishable in memory
Program: a sequence of commands
State: values of all variables when program runs
Large programs use procedural abstraction
Examples of imperative languages:
Cobol, Fortran, C, Ada, Perl
Historically: PL1, Algol, Pascal

43. Object-oriented
Collection of objects (instantiated from classes) that interact by passing messages that transform the state.
Need to know:
Ways of sending messages
Inheritance
Polymorphism
Examples of OO languages:
Smalltalk, Modula, Java, C++, C#, Python

44. Functional
Models a computation with a collection of functions acting on a set of objects, usually lists.
Input: domain of the function
Output: codomain of the function
Functional languages are characterized by:
Functional composition
Recursion
Examples of functional languages:
Lisp, Scheme, ML, Haskell

45. Logical
Logic programming declares what outcome the program should accomplish, rather than how it should be accomplished.
Programs are:
Sets of constraints on a problem
Achieve all possible solutions
Nondeterministic, in some cases
Example of a logic programming language:
Prolog

46. Special Languages Symbolic computation Mathematical Music Markup
Macsyma, Mathematica, Maple, Reduce
Mathematical
APL, Basic, Cayley
Music
ChucK
Markup
HTML, MusicXML, LaTeX
Scripting
AWK, Perl, JavaScript, PHP
and hundreds more for every special circumstance