CS 641 Lecture -*- Outline -*-

* style (or model) vs. problems
	(what's the match?)

** styles vs. kinds of problems that work well

------------------------------------------
  WHAT KINDS OF PROBLEMS WORK WELL IN...

Declarative (+ higher-order) style?




Declarative Concurrent (+ demand-driven) style?





Message Passing style?





Relational (logic programming) style?




Explicit State (ADT, OO) style?







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

        ... declarative style:
	infinite data structures
	polymorphism (generic programming)
	tool building
        semantics
        web apps
        functional transformations

        ... declarative concurrent (+ demand-driven) style
        dataflow problems (order-determined automatically)
        pipelines (producer-consumer, filtering)
        stream computations
        stream objects (e.g., circuit simulations)

        ... message passing style
        agent computation problems (even with state)
        cooperating finite state machines
        robust, dependable systems (as in Erlang)

        ... relational (logic programming style) style
        recording specifications (e.g., for test oracles)
        rapid prototyping (explorations)
        search in small domains
        database interaction, especially queries

        ... OO style
	conceptual modeling
	simulation
        changing domains (planning for change)
        prototyping


** What kinds of things are not easily done in a given style?
------------------------------------------
    WHAT IS NOT EASILY DONE IN ...

Declarative style?




Declarative Concurrent style?




Message Passing style?




Relational style?




Explicit State (ADT, OO) style?






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

        ... declarative
                storage and sharing of time-varying data
                interaction with concurrent agents in the real world

        ... declarative concurrent
                [storage and sharing of time-varying data]
                merging separate streams
                dealing with multiple clients without making them wait

        ... message passing style
                sharing of time-varying data in a modular way
                reasoning about uses of a component

        ... relational 
                [storage and sharing of time-varying data]
                interaction with concurrent agents in the real world
                control of the search
                

        in models that build on others,
           some problems are "inherited" from underlying models