CPS 506Comparative Programming
LanguagesImperativeProgramming Language
Paradigm
Introduction• Oldest and most well-developed paradigm• Mirrors computer architecture• Series of steps
– Retrieve input– Calculate– Produce output
• Procedural Abstraction– Assignments– Loops– Sequences– Conditional Statements
• Examples– Cobol, Fortran, Ada, Pascal, C, Perl
What Makes a Language Imperative?
• In a von Neumann machine memory holds:– Instructions– Data
• Intellectual heart: assignment statement– Others:• Conditional branching• Unconditional branch (goto)
Flowchart
Procedural Abstraction• Procedural abstraction allows the
programmer to be concerned mainly with a function interface, ignoring the details of how it is computed.
• The process of stepwise refinement utilizes procedural abstraction to develop an algorithm starting with a general form and ending with an implementation.– Ex: sort(list, len)
Expressions and Assignment
• Assignment statement is fundamental:target = expression
• Copy semantics• Expression is evaluated to a value, which is
copied to the target; used by imperative languages
• Reference semantics• Expression is evaluated to an object, whose
pointer is copied to the target; used by object-oriented languages.
• There exist vast libraries of functions for
most imperative languages.• Partially accounts for the longevity of
languages like Fortran, Cobol, and C.
Turing Complete• Integer variables, values, operations• Assignment• If• Goto
• Structured programming revolution of 1970s replace the Goto with while loops.
C• C was originally designed for and
implemented on the UNIX operating system on the DEC PDP-11, by Dennis Ritchie.
• Its parent and grandparent are B and BCPL, respectively.
• The operating system, the C compiler, and essentially all UNIX applications programs are written in C.
• C is not tied to any particular hardware or system, however, and it is easy to write programs that will run without change on any machine that supports C.
Influences• Multics, PL/I• Application: typesetting documentation• PDP-11: 16-bit minicomputer; 32 KB
memory• BCPL: typeless• Portability: big-endian vs. little-endian
machines• Good code from a non-optimizing compiler• Hardware support for: ++, --, +=, etc.
General Characteristics• Relatively low level language• Macro facility• Conditional compilation• Lacks: iterators, generics, exception
handling, overloading• Assignments are expression; ex: strcpy
Dynamic Allocationint *a;...a = malloc(sizeof(int) *size);/* ANSI C: a = (int *) malloc(sizeof(int) *size);
C++: a = new int[size]; *//* deallocation left to programmer */
#include <stdio.h>#include <stdlib.h>#include "node.h"struct node *mknodebin(char op1, struct node *left,struct node * right) {
struct node *result; result = (struct node*)
malloc(sizeof(struct node)); result->kind = binary; result->op = op1; result->term1 = left; result->term2 = right; return result;}
struct node *diff(char x, struct node *root){
struct node *result; switch (root->kind) { case value: result = mknodeval(0); break; case var: result = mknodeval(
root->id == x?1:0); break;
case binary: switch (root->op) { case '+': result = mknodebin(
Plus,diff(x, root->term1),
diff(x, root->term2)); break; ... return result;}
Ada• developed in late 1970’s by US
Department of Defense (DoD)• DoD spending billions of dollars on
software• over 450 languages in use• solution: standardize on one language• Higher Order Language Working Group
General Characteristics• influencs: Algol, Pascal• large language; case insensitive• unlike C, array indexing errors trapped• type safe• generics • exception handling -- strictly control
type union =
record case b : boolean of
true : (i : integer);false : (r : real);
end;var tagged : union;begin tagged := (b => false, r => 3.375);
put(tagged.i); -- error
generic type element is private; type list is array(natural range <>) of
element; with function ">"(a, b : element) return
boolean;
package sort_pck is procedure sort (in out a : list);end sort_pck;
package sort_pck isprocedure sort (in out a : list) isbegin
for i in a'first .. a'last - 1 loop for j in i+1 .. a'last loop if a(i) > a(j) then declare t : element; begin t := a(i); a(i) := a(j); a(j) := t; end; end if;
type Matrix is array (Positive range <> of Float, Positive range <> of Float);function "*" (A, B: Matrix) return Matrix is
C: Matrix (A'Range(1), B'Range(2)); Sum: Float;begin if A'First(2) /= B'First(1) or A'Last(2) /= B'Last(1) then raise Bounds_Error; end if;
for i in C'Range(1) loop for j in C'Range(2) loop Sum := 0.0; for k in A'Range(2) loop Sum := Sum + A(i,k) * B(k,j); end loop; Result(i,j) := Sum; end loop; end loop; return C;end "*";
• Perl is:• widely used• a scripting language (originally for Unix)• dynamically typed• encourages a variety of styles• supports regular expression pattern matching
Scripting Languages
• “glue”• take output from one application and reformat into desired input format for a different application.• most time is spent in the underlying applications.• also used for Web applications
General Characteristics• dynamically typed• default conversion from one type to
another (vs. Python)• result is distinct operators; ex: . for
string concatenation• types: numbers, strings, regular
expressions• dynamic arrays: indexed and
associative
• String vs. numeric comparisons:
10 < 2 # false - numeric10 < "2" # false"10" lt "2" # true - string10 lt "2" # true
• Indexed Arrays
@a = (2, 3, 5, 7); # size is 4...$a[7] = 17; # size is 8; # $a[4:6] are undef
@array = (1, 2, 'Hello');@array = qw/This is an array/;
@shortdays = qw/Mon Tue Wed Thu Fri Sat Sun/;print $shortdays[1];
@10 = (1 .. 10);print "@10"; # Prints number starting from 1 to 10
• Indexed Arrays
@array = (1,2,3);print "Size: ",scalar @array,"\n";
@array = (1,2,3);$array[50] = 4;
print "Size: ",scalar @array,"\n";print "Max Index: ", $#array,"\n";
This will returnSize: 51Max Index: 50
• Associative Arrays
%d = (“bob” => “3465”,“allen” => “3131”,“rebecca” => “2912”);
print $d{“bob”}; # prints 3465
• Many different ways of saying the same
thing• Much of the syntax is optional;• Perl 5 added support for classes and
objects• Great strengths: support for regular
expressions• Scalar variables start with a $• Indexed arrays with an @• Hash arrays with %
Strings• Double quotes: special characters
interpreted– ex: “$a \n”– forms: “ “, qq{ }, qq/ /
• Single quotes: special characters uninterpreted– forms: ‘ ‘, q{ }, q/ /
while (<>) { ... }
is same as:while ($_ = <STDIN>) { ... }
where:<> is read a linereturns undef at end of file; undef interpreted as falseno subject: $_if $_ =~ m/pattern/ # implied subject, operator
%hash = ('name' => 'Tom', 'age' => 19);print %hash;
nameTomage19
sub display_hash{ my (%hash) = @_; foreach (%hash) { print "$_ => $hash{$_}\n"; }}
#! /usr/bin/perlif (@ARGV < 1) { die "Usage mygrep string \n" ; }
use strict;my $string = shift(@ARGV);my $ct = 0;my $line;while ($line = <STDIN>) { $ct++; if ($line =~ m/$string/) { print STDOUT $ct, ":\t", $line; }}exit;
Ex: Mailing Grades• typical glue program• student grades kept in a spreadsheet• after each project/test, mail each student
her grades• include averages• export data in comma-separated value
format (CSV)• CSV format varies by spreadsheet
• ::Proj1:Test1:::::Total:Average• ::50:100::::::150:• Tucker:[email protected]:48:97:::::145:96.66666666
• Noonan:[email protected]:40:85:::::125:83.33333333
• Average::88:91:::::135:90
• Main program - part 1• retrieves class designation from
command line• opens CSV file for input• or die is a common idiom• declares some useful constants
(some should be command line options)
#! /usr/bin/perl
use strict;my $class = shift;my $suf = ".csv";open(IN, "<$class$suf") || die "Cannot read: " . "$class$suf\n";
my $sep = ":";my $tab = 8;
• Main program - part 2• reads grade column names• reads maximum points for each
column• adds 100% to @max array
# read header lines: titles, max gradesmy @hdr = &readSplit();my @max = &readSplit();push(@max, '100%');
• Main program - part 3• loop reads 1 student per iteration
(line)• chomp() idiom; irregular• tr deletes “ , '• tokenizer for Perl• last line pops averages from
student array and splits values into columns (printed with each student)
# read studentsmy @student;while (<IN>) { chomp; tr /"'//d; push(@student, $_);}my @ave = split(/$sep/, pop(@student));
• Main - part 4• for loop generates mail, 1 student
per iteration• student grades split into columns• subroutine call; & optional
• mails averages to script invoker• prints number of student emails
generated
# gen mail for each studentmy $ct = 0;foreach (@student) { my @p = split(/$sep/); $ct += &sendMail(@p);}$ave[1] = $ENV{"USER"};&sendMail(@ave);print "Emails sent: $ct\n";exit;
• sub readSplit • reads a line; note $_ is global• chomp idiom• tr deletes quotes• splits line and returns array of
columns
sub readSplit { $_ = <IN>; chomp; tr /"'//d; my @r = split(/$sep/); return @r;}
• sub sendMail • no formal parameters• shift -- call by value• @_ array reference -- call by reference• return if student has no email address• open pseudo file or die• MAIL is a pipe to Berkeley mail
command• s option is subject• $email is mail address
sub sendMail { my $name = shift; my $email = shift; return 0 unless $email; open(MAIL, "| mail -s '$name Grades' $email") || die "Cannot fork mail: $!\n"; print MAIL "GRADE\t\tYOUR\tMAX\tCLASS\n", "NAME\t\tSCORE\tSCORE\tAVE\n\n";
• sub sendMail -- for loop• for each column• skip column if empty header -- not a
grade• otherwise print header• if column value starts with a digit, round
value to an integer; otherwise print value• print maximum points• print average (rounded)
my $ct = 1;
foreach (@_) {
$ct++; next unless $hdr[$ct]; print MAIL "$hdr[$ct]\t"; print MAIL "\t" if length($hdr[$ct]) < $tab;
if (/^\d/) { print MAIL int($_ + 0.5); }
else {
print MAIL $_; }
print MAIL "\t$max[$ct]\t"; if ($ave[$ct] =~ /^\d/) { print MAIL int($ave[$ct] + 0.5); } else { print MAIL $ave[$ct];} print MAIL "\n"; } # foreach return 1;} # sub sendMail
• $_ : implied object/subject• $ARG : default input• $. : input line number• $/ : input record separator : default \n– undef $/; $_ = <IN>; # reads entire file
• $, : output field separator in print• $\ : output record separator• $" : list separator : default space• $[ : starting array index : default zero
Regular Expressions• Operators• m// -- match, m optional• s/// -- substitute• split -- array returning function
• Modifiers• i -- case insensitive• m -- treat string as multiple lines• s -- treat string as a single line• x -- extend with whitespace and
comments