Introduction
| Download
| Publications
| Notes
| Changes
SPARCL
-
Introduction
What it is: SPARCL is a language that helps you
do exploratory programming. It was developed to test
the idea that visual programming, logic programming,
and programming with sets (with partitioning constraints) are highly complementary
approaches to programming that when combined produce a good language for
exploratory programming. The implementation of SPARCL is only an academic
research version: it demonstrates of some of the possibilities of the SPARCL
approach. The user environment for the two dimensional representation is
fairly complete and is reasonably performant, so you can get an idea of
what it's like to build and "read" SPARCL programs. Its most
notable drawback is that the interpretation of SPARCL programs is very slow.
Also, the three-dimensional representation implementation is rudimentary.
What it looks like:
You should look at the gallery
of SPARCL program images for an idea of what programs look like.
What it is, in detail:
For an extended introduction to the SPARCL language, there is a SPARCL tutorial
that has been modified for viewing on the web. This is an adaptation of
the interactive tutorial that is part of the SPARCL Integrated Development
Environment.
What it is, a reference:
The HTML version of the online help
for SPARCL provides a brief reference "manual" for the commands
and concepts of SPARCL.
Who did it: The
SPARCL system was created by Lindsey Spratt
as part of his PhD research for Dr. Allen Ambler
in the Electrical Engineering and Computer Science Department
of the University of Kansas. Some facilities
for this project were provided by DesignLab.
Funding for one summer was provided by a KU Summer Graduate Fellowship.
-
Download
Download SPARCL_2E2.sea.hqx (1.7 Mbytes).
Download SPARCL Read Me
SPARCL requires Macintosh system 7 to 8.5.1, or Mac OS
X 10.2.4 or greater (Classic mode). It has not been rebuilt to run under
Mac OS X, and there may be many bugs (e.g., I think there is a problem with
file system interactions).
To use the QuickDraw3D modeling of the three-dimensional
representation, you must have QD3D installed. You can find it here.
Similarly, to use the POV-Ray modeling, you must have
POV-Ray. You can find it here.
-
Publications
SPARCL papers by Lindsey Spratt
and Dr. Allen Ambler are:
-
Notes
-
Exploratory programming.
Exploratory programming is useful when you have a complex,
poorly-understood problem. It is the technique where the process of programming
a solution to that problem is an essential part of the process of developing
an understanding of the problem. The programming process helps in several
ways: it requires you to precisely characterize your understanding of the
problem (in order that you can create a program at all); reviewing the program
representation deepens your understanding and exposes misunderstandings:
examining the program behavior (by executing the program in various "test"
versions of the problem) both in terms of the results of the execution of
the program and the trace of that execution helps develop insight into otherwise
obscure relationships among the parts of your solution.
This is something like prototype-oriented software development.
In prototype-oriented development, one produces a prototype solution and
tries it out with the clients of the development project (or a representative
sample of these clients). Typically, the requirements of the project are
incompletely understood and the prototype-process is used to flesh out these
requirements (typically, user interface issues). So, what one learns from
the prototype-development process is a set of detailed requirements. In
exploratory programming, the requirements may be simple and well-understood
but one has no clear idea of how to achieve them. An attempt at trying to
find an implementation that solves the programming problem gives concrete
expression to a way of thinking about the problem. Such a concrete expression
is valuable for exploring interactions between elements of a complex solution,
since it is difficult to keep all such elements in mind. Having this expression
in the form of an executable program aids in exploring these interactions
by allowing one to try out the program on different inputs and compare the
results, and perhaps more importantly to watch the "trace" of
the execution of the elements of the program. What one learns from the exploratory-programming
process is what the requirements "mean".
-
Visual programming.
The phrase "visual programming" has many meanings.
Here it is used to mean a programming language where program source represents
important relationships in the language diagrammatically ("visually")
instead of linguistically ("linearly" or "textually").
The problem being solved may not be particularly visual. For instance, one
may write a visual program to calculate Fibonacci numbers or factorial,
where the result of the program is a number. Shin eloquently discusses diagrammatic
representations versus linguistic representations in The Logical Status
of Diagrams.
-
Logic programming.
Logic programming involves a fairly direct use of formal
logic in the representation and semantics of a programming language. It
is closely related to theorem proving in its roots. It diverges from theorem
proving in the provision to the programmer of methods to control the computation
involved in "solving" a logic program, and in adapting to the
representation and semantics of the language to the needs of efficient computation.
The line between theorem proving and logic programming is vague, but some
systems are clearly within one "camp" or the other. Constraint
programming and functional programming are closely related to logic programming.
Depending on how you look at it, any one of them can be considered to subsume
the other two. The primary logic programming language is PROLOG, with major
contenders for the title of "second generation" logic programming
language being GOEDEL or MERCURY.
Lindsey Spratt
Introduction
| Download
| Publications
| Notes
| Changes