CS 541 Lecture -*- Outline -*-

* course summary

** review of syllabus
------------------------------------------
    WHAT WE STUDIED

Models
   - Declarative
     + Exceptions + Security
   - Concurrent
     + By-need evaluation
   - Message Passing
   - Explicit State

Programming
   - Functional
   - Declarative
   - Declarative Concurrent
   - Message passing

------------------------------------------

   Security features are NewName and !! (read-only views)

   Q: What's the difference between the declarative and functional models?
   Q: What does the concurrent model add?

** language design and model ideas
------------------------------------------
 WHAT DID WE LEARN ABOUT MODELS
      AND LANGUAGE DESIGN?






------------------------------------------

        Q: What primitives are helpful, powerful?

             - dataflow variables
             - closures, higher-order functions
             - exceptions
             - NewName and read-only views
             - message passing
             - cells

        Q: What techniques?
                grammatical-based explanation and semantics
                configurations and transitions in little step sementics

                kernel-based language with sugars

        Q: What principles?
                regularity, uniformity

** Programming lessons
	Q: What did you learn about programming from each?
------------------------------------------
  WHAT DID WE LEARN ABOUT PROGRAMMING?



------------------------------------------

*** Declarative

    - Can use dataflow variables to make functions tail recursive
    - Can use partial values to represent streams

*** Declarative concurrency

    - Use to get order of execution automatically determined
           (with dataflow variables)
    - Can get simple concurrent systems with streams
    - Stream-based systems are easier with by-need evaluation
    - Can use by need evaluation to fix impedence (rate) mismatches

*** Message Passing

    - Client server programming

    - Finite state designs can be easily programmed with messages

*** Explicit State

    - Get modularity with encapsulation of persistent data

*** Comparison
        Q: What are the advantages and disadvantages (limits) of each paradigm?
                (see also the styles-vs-problems.txt file)

        Q: How do they compare for making programming easier?

        research question: Can we combine the advantages somehow?


** what's the value of all this?
------------------------------------------
        WHAT'S THE VALUE OF ALL THIS?

Programming is language design:
 - make it easy for your users
 - give them good notation
 - provide primitives,
   ways to combine them,
   and abstraction facilities

Kernel language approach:
 - find primitives that give new power
 - add sugars on top of these


------------------------------------------

** where to go from here
------------------------------------------
       WHERE TO GO FROM HERE

Further classes:
  - 540 Compilers
  - 641 (Semantic models for Prog. Langs.)
  - Seminar on PL design
------------------------------------------