CS 7 Introduction to Computer Programming

Document Sample
CS 7 Introduction to Computer Programming Powered By Docstoc
					CS 7: Introduction to
Computer Programming

         Algorithms
Review
   What are the 5 generation languages
    (“GL”)?
       1 GL – machine language
       2 GL – assembly language
       3 GL – high level language
       4 GL – “non-procedural, specification
        language”
       5 GL – “constraint-based, Artificial
        Intelligence language”
Trade-offs among the 5 G’s
   Productivity
       Time to write, debug, maintain code
   Portability
       Ease of taking program written on 1 computer and
        moving it to another
   Efficiency
       Time it takes code to run
       Amount of space it takes to run
   Task Dependent
       Is the language developed for a specific task?
1 GL
   Example
       000000 00001 00010 00110 00000 100000
       Add registers 1 and 2, place result in register 6
   Low productivity
       Lots of instructions needed for simple tasks
   Low portability
       Different machine languages for different architectures
   High efficiency
       can take advantage of architecture dependent features
       can write more quick and compact code
   Not task dependent
   Everything ultimately must be in machine code!
2 GL - MIPS
   Example
        add $1, $2, $6
        Add registers 1 and 2, place result in register 6
   Low productivity
        Lots of instructions needed for simple tasks
             Usually 1-to-1 correspondence with machine language
        Easier to read
   Low portability
        Different machine languages for different architectures
   High efficiency
        can take advantage of architecture dependent features
        can write more quick and compact code
   Not task dependent
3 GL – Java, C++, BASIC,
FORTRAN
   Example
       d = e + f;
       Add the values in e and f, place result in d
   High productivity
       1 instruction can be 100, 1000 lines of machine code
       Much more like human language
   Highly portable
       Run on any machine with necessary compiler, interpreter
   Efficiency
       Not as good as machine code
   Not task dependent
4 GL – SQL, Visual Basic’s GUI
Creator
   Example
       FIND ALL RECORDS WHERE NAME IS “HOFFMANN”
   High productivity
       Easy than 3 GL
   Highly portable
       Run on any machine with necessary compiler, interpreter
   Efficiency
       Not as good as machine code or high level language
   Task dependent
       SQL used for database queries
       Visual Basic’s GUI Creator is for designing Graphical User
        Interfaces (GUIs)
5 GL – Prolog, Neural
Networks
   Example
       Specify neural network architecture for learning to
        map written character to ASCII equivalent
   High productivity
   Highly portable
   Efficiency
       Not as good as machine code or high level
        language
   Task dependent
       Used to solve problems with specific constraints
Algorithms
Algorithms - Definition
   Set of instructions used to complete a
    task
   Can be represented as
       Pseudocode – list of steps, is precise but
        not implemented in programming language
       Flowchart – graphical representation
Algorithms - Representation
   How do you…
       Make a peanut butter sandwich?
       Calculative a derivative?
       Find a job?
       Do the hokey pokey?
Hokey Pokey – List of Steps
Representation
   Volunteers?
   Anything unclear in the steps the song
    gives?
Flowchart symbols
   Action Symbol
       Instructions changing a state
   Decision Symbol
       Instructions testing a state
   Flowline
       Instructions transferring to next step
   Start/End Symbol
Control Structures
   Bohm & Jacopini showed all programs
    could be written in terms of 3
    structures:
       Sequence – which instruction should be
        done next?
       Selection – select between options
       Repetition – repeat an action while a given
        condition stays true
Sequence


   1) Open the jar
   2) Scoop out the peanut butter
   3) Spread the peanut butter on the
    bread
Selection
   Single Selection (if)
                                               True
       If you’ve won the lottery:        Won
                                        lottery?
                                                      Raise
                                                      Hand
          raise your hand         False

   Double Selection (if-else)
       If you’re happy:
           smile              False    True
        else:         Frown       Happy?      Smile

           frown
Selection (continued)
 Multiple Selection (switch)         True
                                Light
If the light is ...             Red?
                                             Stop

                           False
   red    -> stop               Light
                                      True
                                              Go
                               Green?
   green -> go             False
                                      True
   yellow -> slow down          Light        Slow
                                  Yellow?    Down
                                False
Repetition
   While          True                     while it’s still clumpy
            Mixture
                             Stir             Stir the mixture
            Clumpy?
                 False

                                         ask parents if must eat
   Do-while              Must I eat     vegetables
                          Veggies?     while parents say “Yes”

                          Parent say True
                            “Yes”?
                                 False
Repetition (continued)
   For
                                     Teaching a baby to count
          Counter = 1
                                     from 1 to 10:
                                     counter = 1
                          Add 1
                                     if counter <= 10:
                        to counter
                                       increment counter
                 True
           Counter     Print         print counter number
            ≤ 10?     counter
          False
Hokey Pokey - Flowchart
Pseudocode
  Pseudocode - Algorithm written in way that resembles code:
  Example (from BlackJack)
method computeScore(cards):
  for each card in hand:
      if card is ace:
         add 1 to score
         add 1 to numAces
      else if card is face card:
         add 10 to score
      otherwise:
         add face value to score
  while numAces > 0 and count < 21:
      add 10 to counter
  return counter value
Algorithms - characteristics
   What kinds of things are we seeing in
    these tasks?
       They have an input, an output, and do
        some processing
       That processing needs to terminate, be
        unambiguous, and simple to perform (we
        want to be able to easily implement it from
        the algorithm)
References
   Deitel, H.M., and Deitel, P.J. Java: How
    to Program, 3rd edition. Chapter 4,5
   Wikipedia.
   http://www.soi.city.ac.uk/~tony/dbms/
    4ges.html