A limited number of places are still available for the functional programming
section of the upcoming workshop:
"Integrating Recent Research into Computer Science Undergraduate Curricula:
Software Engineering, Functional Programming,
Neural Networks, and Computational Geometry."
The workshop will be held on the campus of The Evergreen State College in
Olympia, Washington, from July 7-11, 1997. The announcment of the workshop
and registration materials are at
http://www.evergreen.edu/user/CISE/
Enclosed below are a brief description of the functional programming section
and abstracts of the talks by Chris Okasaki, John Launchbury, and Erik Meijer.
While the close of registration has officially passed, we are still
accepting registrations. The cost to the participant is $150 (overnight
accommodations, meals, materials, etc) with NSF/CISE supporting the rest of
the costs. A stipend of up to $150 is also available.
If you have questions, contact:
Jeanine L. Elliott
Director, Washington Center for Improving the Quality of Undergraduate
Education
L2211, The Evergreen State College
Olympia, WA 98505
360/866-6000, ext. 6609
360/866-6662 (FAX)
[EMAIL PROTECTED]
----------------------------------------------------------------------------
Recent Research Results and Undergaduate Curricular Innovations
Functional Programming Track
July 7-11, 1997
http://www.evergreen.edu/user/CISE/
Since a growing number of computer science departments are
including functional languages such as Scheme, ML, Gofer and
Hugs in the undergraduate curriculum, it is important that faculty
who are teaching or would like to teach functional programming be
familiar with recent developments in this area. In this workshop
guest lecturers will bring the participants up to date on recent
research results in the theory and practice of functional
programming. In addition to attending the invited lectures, the
participants will also have the opportunity to share their teaching
experiences and to work together in teams to identify topics that
could be incorporated into the undergraduate curriculum and to
develop appropriate course material, such as workshops, labs,
undergraduate research projects, or bibliographies, that could be
used to promote the integration of such results.
Speakers:
Chris Okasaki, Carnegie Mellon University
Title: Teaching Data Structures From a Functional Perspective
Abstract:
Teaching data structures such as red-black trees or binomial queues in
an imperative language can be fairly gruesome because the high-level
ideas are often obscured by masses of intricate pointer manipulations.
In functional languages, on the other hand, these pointer
manipulations take place behind the scenes, leaving both students and
teachers free to concentrate on the high-level ideas. We will explore
some recently developed functional data structures and consider how
they might be taught in this fashion. Functional languages are not a
panacea for the instructor, however. We will also discuss some of the
limitations in this approach to teaching data structures.
John Launchbury, Oregon Graduate Institute
Title: Formalizing Programming Idioms
Abstract:
Many software components turn out to be instances of fairly general classes
of problems. By studying the whole class it is often possible to develop
formal "idioms" which enable individual instances to be expressed rapidly
and concisely. Functional languages are equipped with sufficient expressive
power to capture such idioms, and to develop reasoning laws about the
combining forms which result. In some cases the choice of combining forms
is strongly guided by what is already known about the application area, but
in other cases the combinators need to be developed from scratch. Here
especially, an awareness of the general theory of monads can provide
significant guidance to the developer. In this full-day tutorial, there
will be laboratory sessions enabling the participants to come to grips with
the whole arena of combinator programming.
Erik Meijer, Utrecht University
Title: Internet Programming in Haskell
Abstract:
Many pages on the web are still static, they have the same appearance every
time they are viewed. It is also possible to write dynamic web pages whose
contents are created by a program, and so can appear different on each visit.
Such programs are called CGI scripts, and are run by the web server that
provides the page. CGI scripts can receive complicatedly encoded input from
the client's web browser, and can return output in a variety of formats
(plain text, HTML, JPEG etc) which the client then sees.
Any programming language that can read from the standard input, write to
the standard output, and access the environment variables is suited for
writing CGI scripts. Most CGI scripts today are written in languages like C
or PERL. The latter language is popular because it has rich features for
manipulating text (regular expressions). This paper describes a library for
writing CGI scripts in Haskell. Input and output coding of CGI scripts is
handled by a wrapper, a higher-order function that passes the
client's input as an association list of keys and values to its argument
function. Thus the main part of the application, the function inside the
wrapper, need not be at all concerned with coding matters. The decoder
itself is conveniently expressed with parsing combinators. The
application's output can be of a variety of types; Haskell's class system
conveniently allows the wrapper function to be overloaded accordingly. In
particular, HTML can be represented by a simple tree type. A set of
combinators is provided using which complicated HTML pages can be assembled
easily.
Many interactive programs can be modeled as finite state machines. As an
example, we program a calculator as a CGI script. The client displays an
HTML form with one button for each key on the keypad. Pressing a key
invokes the CGI scripts on the server, which sends back an HTML description
of the new appearance of the calculator. The calculator's state is held in
`hidden fields' of the HTML form. Abstracting from this particular example,
we define combinators to implement finite state machines as CGI scripts.
Our CGI scripts are executed by the Hugs interpreter, which
results in quite small and reasonably efficient programs. The internet
bottleneck is so narrow that the performance of the functional programs is
not an issue.
Biographies:
John Launchbury, after receiving an award winning PhD from Glasgow
University, continued his research in functional languages first as a
faculty member at Glasgow, and then more recently at Oregon Graduate
Institute. His work has been largely on the semantic underpinnings of
functional languages, and in developing practical consequences from
these.
Erik Meijer is currently a visiting research professor at the Oregon
Graduate Institute, being on leave from Utrecht University in the
Netherlands. He is known for his work on Constructive Algorithmics
(Squiggol), but nowadays he tries to spend more of his time on
practical applications of functional programming.
Chris Okasaki is a researcher at Carnegie Mellon University, known for
his work on functional data structures, especially amortized data
structures based on lazy evaluation. He is currently developing
libraries of efficient data structures for both Standard ML and
Haskell.
Scholar in Residence: Chris Haynes, Indianna University.
Christopher T. Haynes is Director of Undergraduate Studies and Associate
Professor in the Computer Science Department of Indiana University at
Bloomington, where he directs the NSF-funded Scheme Educational
Infrastructure project. Professor Haynes is co-author of the MIT
Press/McGraw Hill text "Essentials of Programming Languages" and chaired
the IEEE Scheme standard working group. Professor Haynes has authored over
a dozen programming language research papers, with particular interest in
programming language type systems and symbolic computation. As well as
teaching at Indiana University since 1982, he has taught graduate courses
at MIU in Fairfield, Iowa, IISc in Bangalore, India, and ITESM in
Monterrey, Mexico, and has consulted with industry. He received a PhD
degree in computer science from the University of Iowa in 1982 and a BA
degree in mathematics from Lehigh University in 1973.
