Download 14 - Villanova Computer Science

Programming Languages
Meeting 14
December 6/7, 2016
CATS
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
Topics for Final
• Syntax and syntax specification: EBNF
– Nonterminal, terminal, production, start symbol
– Grammar of expressions
• Inferred precedence and association
– Syntax trees
– Examples: Pam, REF, expressions, dates, AWK, …
• Abstract syntax
Topics (1.1)
• Semantics and semantic specification
– Env, Loc, Store, Value, Memory
• Denotational semantics
– Program functions
– Backus notation for functional programming
Topics (2)
• Semantics examples
– REF, a language of pointers
– Multiple assignment statements
• Control structures
– Sequence
– While
– If-then
– For
Topics (3)
• Parameter passing
– Value
– Result
– Value-result
– Reference
– Name
– Reserved variable
Topics (4)
• Functional programming
– Lists
– Atoms
– Primitive functions
– Functionals
– User-defined functions
– Predicates
Topics (4.1)
• Developing from primitives and functionals
– Use of recursion
• Catching error conditions
– Proper error messages
• Measures of lists
– Length
– Depth
Topics (5)
• Scripting languages
– AWK
– Perl
• Regular expressions
AWK Questions
AWK Exercises
1. 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}
AWK Programs
What do each of these programs do?
/^$/ {count++}
END {print count}
/<..*>/
AWK Exercises
1. 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.
PERL
•
•
•
•
Practical Extraction and Support Language
A glue language under Unix
Written by Larry Wall
See www.perl.com
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
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
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
Example 1
#!/usr/local/bin/perl –w
print(“Hello, world!\n”);
Example 1
#!/usr/local/bin/perl –w
print(“Hello, world!\n”);
Inserts new line character
PERL
• Scalars
– Integer, real, string
• Identifier must start with $
• Arrays
– Indexed by integers
• Identifier must start with @
– Indexed by strings
• Identifier must start with %
Example 2
#!/usr/local/bin/perl –w
print(“What is your name? ”);
$name = <STDIN>;
chomp($name);
print “Hello, $name!\n”;
Example 2
#!/usr/local/bin/perl –w
print(“What is your name? ”);
$name = <STDIN>;
Critical space
chomp($name);
print “Hello, $name!\n”;
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”;
PERL
• Control structures
if-then-elsif
foreach $element (%list) { … }
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”};
PERL
• Dynamically typed
– 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
Arrays of Strings
• 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
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
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)
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;
Examples (2)
Watch the values of $s, $t, $x, $y
$x = 14;
$x = $x – 1;
$x -= 1;
--$x;
$y = $x--;
$s = “llama ”;
$t = $s x 3;
$t .= “moose ”;
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.
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
Examples
sub say_hello {
print “hello, world\n”;
}
Invoked by
say_hello();
Examples (2)
sub say_what {
print “hello, $what\n”;
}
Invoked by
$what = “everyone”;
say_what();
Examples (3)
sub say_hello_to {
print “hello, $_[0]\n”;
}
Invoked by
say_hello_to(“everyone”);
Examples (4)
sub say {
print “$_[0], $_[1]\n”;
}
Invoked by
say (“Good”, “morning”);
Examples (5)
sub say_lots {
foreach $_ (@_) {
print “$_ “;}
print “\n”;
}
Invoked by
say_lots (“Good”, “morning”, “class”);
Thanks for being a class that has had fun while
learning.
Paradigms
• Programming paradigm: pattern of problemsolving thought that underlies a particular
genre of programs and languages.
• Four main programming paradigms:
– Imperative
– Object-oriented
– Functional
– Logic (declarative)
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
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
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
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
Special Languages
• Symbolic computation
– 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