Introduction to ITEC 320

What is Procedural Programming?

What is Procedural Programming?

• Short answer, procedural programming (PP) is not OOP (Object Oriented Programming)
• That is:
  • no extends (and so no polymorphism)
  • no classes
  • But we need a data structure with fields: Yes, Ada records have fields as do classes
  • But records do not need references
  • like having all methods static
  
  
• Well, procedural languages are not declarative either
• Declarative languages, such as PROLOG and LISP, are neither OOP nor PP (more in ITEC 380)

Summary

• OO is easy as PIE (Polymorphism, Inheritance, Encapsulation)


• Procedural Programming:
  • no polymorphism and no inheritance
  • encapsulation (ie limiting access to fields and methods) is done differently
  • fields in records, but references not required
  • references only as needed

Where is Procedural Programming Used?

Use PP When You Need ...

• Efficiency: Time and space, such as in
• Weather simulation
• Hard real time
• Embedded systems


• Closeness to machine
• Meaning: specify sizes and bit layouts and do bit manipulation
• Example: Embedded systems


• Reliability and Security
  • Example: need to predict memory usage to avoid running out of memory
  • Example: need to know at compile time which method will be called (polymorphism?)

Languages in ITEC 320

Ada

• ITEC 320 primarily uses Ada


• Ada is a Procedural language
  • Ada supports OO, but you don't have to use it, or pay the costs associated with it


• Ada is carefully designed to meet software engineering requirements
  • Easy to produce reliable programs
  • Studies: life cycle costs, low error rate

Other languages

• We will frequently contrast Ada with Java
• We will occasionally contrast Ada with C and C++

Hello World

• Our first program

   with Ada.Text_IO; use Ada.Text_IO;
   procedure hello is
   begin
      put_line("Hello there!");
   end hello;
   

• Command line compile and run:

   >gnatmake hello
   ... Compiler output omitted
   >./hello
   Hello there!
   >
   

Why Ada

Ada: An Excellent Procedural Language

• Design goals and characteristics match procedural areas
• Syntax from Algol family (not C family)
• New ideas and perspectives

Design Goals

• Efficiency
• Reliability
• Concern for programmer (eg readable, least surprise)
• Support for large programs with long lifetimes

Characteristics of Ada

• Efficiency: Speed and space
• Only pay for features if need them (eg OO)
• Syntax supports building reliable systems


• Very rich type system
• Contracts - Catch errors early (a big win!):
  • Strong type checking (C < C++ < Java < Ada)
  • Integer ranges and new types


• Expressive - Easy to express what you want to say, reliably and at the problem level
  • vs Permissive - Allows constructs that interfere with readability or reliability
    • eg C, called high level assembly
• Hits sweet spot: Can program well at both high and low levels

Syntax is Algol family

• C family: C, C++, Java - You have seen
• Algol family: Algol, Pascal, Ada - Different from C family
• { vs if, loop, is
• } vs end if, end loop, end record, function foo ... end foo vs }
• else if vs elsif
• =, == vs :=, =
• int x vs x: Integer

New Ideas and Perspectives:

• Programming w/o classes
• How the language accomplishes efficiency and reliability
• Rich type system
• Numeric ranges, subtypes, new numeric types
• No references: understanding objects vs pointers-to-objects
• Pointers - Explicit: allocation, dereference, deallocation

Sample Ada Code

Type System: Expressive and Reliable

• Expressive - Easy to express what you want to say, reliably and at the problem level


• Reliable
• Program at level of problem
• Not a level of machine (where everything is an integer)
• Catch errors early

Example: Type Naturals and an Integer Range

   n: Natural;
   
   small: Integer range 1 .. 10;
   ...
   small := n;     -- Will an error occur?
   

• Naturals are integers 0 and above
• Small is an integer between 1 and 10
• range 1 .. 10 is a constraint
• Catch n out of range error on assignment, not when small used

Example: Subtype Negative

  subtype Negative is Integer range Integer'first .. -1;

  v: Negative;
  n: Natural;
  ...
  v := n;   -- Compiler warning, runtime error;

• v can hold only negative numbers

Example: Fixed Point Type

• What is the output:

   double penny = 0.01;
   double sum = 0;
   for (int i = 0; i < 100; i++)
      sum += penny;
   if (sum == 1.00) System.out.println("A dollar");
   else System.out.println("Not a dollar");
   

• What about here?

    type Dollars is delta 0.01 range 0.00 .. 1_000_000.00
  
    penny: constant Dollars := 0.01;
    sum: Dollars := 0.00;
  
    for i in 1 .. 100 loop
        sum := sum + penny;
    end loop;
    if sum = 1.00 then  put_line("A dollar");
    else put_line("Not a dollar");
    end if;

• Define a type for dollars and cents
• Avoid roundoff errors!

Example: Type Even

   ...
   subtype Even is Integer 
      with Dynamic_Predicate => Even mod 2 = 0;

   e: Even;
   n: Natural;
   ...

   e := n;              -- Catch error on assignment, not use
   e := e + 1;          -- Catch on compilation?
   

• e can only hold Even numbers


• Hmm, What about this mistake I made:

   ...
   subtype Even is Integer 
      with Dynamic_Predicate => Even mod 2 = 9;

   e: Even;
   n: Natural;
   ...

   e := n;              -- Catch error on assignment, not use
   e := e + 1;          -- Catch on compilation?
   

Example: Close to Machine - Specify Sizes

  -- A bit is, well, size one bit
  type Bit is Integer range 0 .. 1
     with size => 1;

  -- A Bit_Array is, well, size 32 bits
  type Bit_Array is array (1 .. 32) of Bit
     with size => 32;

  b: Bit_Array;

• Variable b is an array, 32 bits long
• Size can go in either place, or both

Example: Close to Machine - Specify Bit Layout

  -- Records with fields
  type Sensor is record  
     Active: Boolean;
     temperature: Integer range 0 .. 127
  end record;

  -- Specify size
  for Sensor'Size use 8;             -- 8 bits

  -- Specify bit layout
  for Sensor use record
     Active at 0 range 0 .. 0;       -- first bit
     temperature at 0 range 1 .. 7;  -- remaining 7 bits
  end record;

  s: Sensor;

• Specify size of s as 8 bits
• Specify which bits of s correspond to which field

Example: Pre and Post Conditions

   ...
   -- Check if needle is in hay at position loc
   function match (needle, hay: String; loc: Positive) return Boolean is
         (for all i in 1 .. needle'length => needle(i) = hay(loc + i - 1))
      with
         pre => loc in hay'length - needle'length - 1;
      
   -- Find location of needle in hay, if it's there
   function search (needle, hay: String) return Natural 
      with
         pre => needle'length in 1 .. hay'length,
         post => (search'result in 0 .. hay'length - needle'length + 1
                  and then
                  (if search'result > 0 then
                     match(needle, hay, search'result)
                  else
                     (for all loc in 1 .. hay'length - needle'length + 1
                        => not match(needle, hay, loc))
                  ));
   

• Pre and post conditions can be used to prove program properties
• The SPARK system can prove:
• AoRTE (Absence of Runtime Errors) in the implementation
• If the precondition is true, then the implementation make the postcondition true
• Callers of search must guarantee its precondition and can assume its postcondition

Ada History and Example Applications

Ada: The Name

Final Words

• ITEC 320 can be a fun course, so have fun!


• Get started on installing a compiler on your personal machine


• Suggestions on success:
1. Come to class!


2. Start your programs early!
3. Start your programs early!
4. Start your programs early!
5. Go to 2
• Give yourself time to climb the learnin curve!


6. Never, never, never, never, never give in!