Programming Languages Tucker and Noonan

1. Programming LanguagesTucker and Noonan Chapter 12: Imperative Programming 12.1 What Makes a Language Imperative? 12.2 Procedural Abstraction 12.3 Expressions and Assignment 12.4 Library Support for Data Structures 12.5 C 12.6 Ada 12.7 Perl CSC321: Programming Languages

2. Imperative Programming • Oldest and most well-developed paradigm • Mirrors computer architecture • Typical Languages • Fortran, Pascal • C, Clite • Ada 83 • Perl CSC321: Programming Languages

3. What Makes Languages Imperative? • In a von Neumann machine memory holds: • Instructions • Data • Intellectual heart: assignment statement • Others: • Conditional branching • Unconditional branch (goto) CSC321: Programming Languages

4. Flowchart CSC321: Programming Languages

5. Procedural Abstraction • Proceduralabstraction 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) CSC321: Programming Languages

6. 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. CSC321: Programming Languages

7. Library Procedures/Functions • There exist vast libraries of functions for most imperative languages. • Partially accounts for the longevity of languages like Fortran, Cobol, and C. • Typical libraries for data structures • Iterators • Vectors • Lists • Stacks, queues, deques, priority queues • Sets and bags • Maps CSC321: Programming Languages

8. Supports • Turing Completeness • Assignment • Sequence • Conditional statement: If • Loop statement: • Goto • Structured programming revolution of 1970s replace the goto with while loops. • Other supports • Integer variables, values, operations • Input/output, error/exception handling, library support CSC321: Programming Languages

9. C • “C was originally designed for and implemented on the UNIX • Operating system on the DEC PDP-11, by Dennis Ritchie. • The operating system, the C compiler, and essentially all • UNIX applications programs (including all of the software • Used to prepare this book) 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.” CSC321: Programming Languages

10. 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. CSC321: Programming Languages

11. General Characteristics • Relatively low level language • Macro facility • Conditional compilation • Lacks: iterators, generics, exception handling, overloading • Assignments are expression • ex: strcpy CSC321: Programming Languages

12. Dynamic Allocation int *a; ... a = malloc(sizeof(int) *size); /* ANSI C: a = (int *) malloc(sizeof(int) *size); C++: a = new int[size]; */ /* deallocation left to programmer */ CSC321: Programming Languages

13. Ex: Grep • Grep is a Unix utility to search for strings in a text file • #include libraries • Two functions • main processes command line arguments • find • Forward reference • First signature/prototype, second definition • Procedure • reads file • search each line • write line if match • fgets CSC321: Programming Languages

14. Ex: Average • Compute min, max, average of a set of numbers • Formatting: scanf, printf • Conditional assignment • 2nd argument to scanf must be an address • caught by some compilers • segment violation at run time CSC321: Programming Languages

15. Average C Code #include <stdio.h> Int main(int argc, char *argv[]) { int ct, number, min, max, sum; sum = ct = 0; printf(“Enter number: “); while (scanf(“%d”, &number) != EOF) { if (ct=0) min = max = number; ct++; sum += number; min = number < min? number : min; max = number > max? number : max; printf(“Enter number: “); } printf(“%d numbers read\n”, ct); if (ct>0) printf(“Average: \t%d\n”, sum / ct); printf(“Maximum:\t%d\n”, max); printf(“Minimum: \t%d\n”, min); } } CSC321: Programming Languages

16. Ada • Developed in late 1970’s by DoD • DoD spending billions of dollars on software • Over 450 languages in use • Solution: standardize on one language • Higher Order Language Working Group • Ada 83 • problem: size of language/compiler • no subsets rule • Hard times during 1990s • use of COTS • Renewed interest • COTS proved problematic • development of Spark Ada • NYU GNAT (Ada) compiler CSC321: Programming Languages

17. General Characteristics • Influences: Algol, Pascal • Large language; case insensitive • Unlike C, array indexing errors trapped • Type safe • Union • Generics • Exception handling -- strictly control CSC321: Programming Languages

18. Tagged Union type union(b: boolean) is = record case b is when true => i : integer; when false => r : float; end case end record; tagged : union; begin tagged := (b => false, r => 3.375); put(tagged.i); -- error case tagged(b) is when true => put(tagged.i); when false => put(tagged.r); end case CSC321: Programming Languages

19. Generics • Generic sort • Sort various data set of different types • Code 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; CSC321: Programming Languages

20. package body sort_pck is procedure sort (in out a : list) is begin 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; end loop end loop; end sort; end sort_pck; CSC321: Programming Languages

21. Ada: Average • Comparable to C • Infinite loop; exit on end of file via exception • Inner loop to catch errors caused by non-numeric data • Exception handling • Wordy than C CSC321: Programming Languages

22. Ada: Average Code Ada.Integer_Text_IO.Put(Ct, 5); Ada.Text_IO.Put(“ numbers read”); Ada.Text.IO.New_Line; if Ct > 0 then Ada.Text_IO.Put(“Average: “); Ada.Integer_Text_IO.Put(Sum/ Ct); Ada.Text.IO.New_Line; Ada.Text_IO.Put(“Masimum: “); Ada.Integer_Text_IO.Put(Max); Ada.Text.IO.New_Line; Ada.Text_IO.Put(“Minimum: “); Ada.Integer_Text_IO.Put(Min); Ada.Text.IO.New_Line; end if End Average; with Ada.Text_IO: with Ada.Integer_Text_IO; Procedure Average is sum := 0; Ct := 0; Ada.Text_IO.Put(“Enter number: “); loop begin Ada.Integer_Text_IO.Get(Number); if Ct = 0 then Min := Number; Max := Number; end if Count := Count + 1; if Number < Min then Min := Number; elsif Number > Max then Max := Number; end if exception when Constraint_Error => Ada.Text_IO.Put(“Value out of range.”); when Ada.Text_IO.Data_Error => Ada.Text_IO.Put(“Value not an integer.“); when Ada.Text_IO.End_Error => exit; end Ada.Text_IO.Put(“Enter number: “); end loop CSC321: Programming Languages

23. Perl • Widely used • A scripting language (originally for Unix) • Dynamically typed • Encourages a variety of styles • Supports regular expression pattern matching • 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 CSC321: Programming Languages

24. 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 CSC321: Programming Languages

25. Arrays • Indexed Arrays • @a = (2, 3, 5, 7); # size is 4 • ... • $a[7] = 17; # size is 8; • # $a[4:6] are undef • Associative Arrays • %d = (“bob” => “3465”, • “allen” => “3131”, • “rebecca” => “2912”); • print $d{“bob”}; # prints 3465 CSC321: Programming Languages

26. Perl: Grep • #! /usr/bin/perl • die "Usage mygrep string \n" if @ARGV < 1; • use strict; • my $string = shift; • my $ct = 0; • while (<>) { • $ct++; • print "$ct:\t$_" if /$string/; • } • exit; CSC321: Programming Languages

27. Comments on Grep • Scalar variables start with a $ • Indexed arrays with an @ • Hash arrays with % • Otherwise: bare word syntax error • use strict forces declaration of variables • local : dynamic scoping • my : static scoping • NB: only 1 $_ CSC321: Programming Languages

28. Strings • Double quotes: special characters interpreted • ex: “$a \n” • forms: “ “, qq{ }, qq/ / • Single quotes: special characters uninterpreted • forms: ‘ ‘, q{ }, q/ / • Comparison • 10 < 2 # false - numeric • 10 < "2" # false • "10" lt "2" # true - string • 10 lt "2" # true CSC321: Programming Languages

29. Loops and Patterns • while (<>) { ... }is same as: while ($_ = <STDIN>) { ... } where <> is read a line • returns undef at end of file; undef interpreted as false • no subject: $_ • if $_ =~ m/pattern/ # implied subject, operator CSC321: Programming Languages

30. Alternative Code • #! /usr/bin/perl • if (@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; CSC321: Programming Languages