introductions

[Alex Shinn]

I was waiting for an official list from the SC before asking
for introductions, but you can see the members if you use
the Google Groups interface anyway. We are

Aaron W. Hsu
Alaric Snell-Pym
Alex Shinn
Alexey Radul
Arthur Gleckler
Bradley Lucier
Brian Harvey
David Rush
Gerald Jay Sussman
Jakob Praher
Jeffrey T. Read
Joe Marshall
John Cowan
Olin Shivers
Patrick Durusau
Robert Smith
Steven Ganz
Thomas Lord

It would be nice if everyone listed here can introduce
themselves.

I'm Alex Shinn, and to reiterate I'm the chair of this
group. I've been a Scheme programmer for 10 years and
participated actively to the community and have contributed
large amounts of code and libraries to several
implementations. Some of my larger projects include IrRegex
and the Hato mail suite. I'm also the author of
chibi-scheme

http://groups.google.com/group/chibi-scheme

Chibi is a very small but fast and full-featured Scheme
interpreter for use as an extension language. It has a
large and growing set of libraries. It also gives away a
lot of my bias - there's not much in Chibi that I'd want to
change.

I'm looking forward to hearing from everyone else!

--
Alex

[Brian Harvey]

> It would be nice if everyone listed here can introduce themselves.

Well I already made a user page on Aaron's wiki but I'll copy it here:

I'm Brian Harvey.

I'm a "Lecturer with Security of Employment" (a tenured full time teacher) at
the University of California, Berkeley, where I teach SICP to about 600
students/year, along with a course on Social Implications of Computing and
other things. My SICP lecture notes and videos are online at
http://wla.berkeley.edu/cs61a
and other course materials are at
http://inst.eecs.berkeley.edu/~cs61a
SICP is our first course for CS and EECS majors. We offer a "zeroth" course
for people without programming background, also Scheme-based, using my book
_Simply Scheme_ [ http://www.cs.berkeley.edu/~bh/ss-toc2.html ].

I started out as a PDP-10 systems hacker at the MIT and Stanford Artificial
Intelligence Labs, until one day a burning bush appeared before me and told me
what I really wanted to do was teach. Well, two burning bushes actually: a
copy of _Summerhill_ that a housemate left lying around the living room, and,
a little later, starting to hang out around the MIT Logo lab. I was a high
school teacher [ http://www.cs.berkeley.edu/~bh/freedom.html ] for a while
before starting to teach freshmen at Berkeley in 1987, where I discovered
SICP, and where I've been teaching it ever since.

For fun I teach fifth graders, using Scratch [http://scratch.mit.edu ]. I'm
involved in a project to add lambda to Scratch! (We're planning to use the
augmented Scratch as the basis for a new zeroth course at Berkeley, which will
be only half programming and the other half "big ideas.")

I also run the Berkeley Logo development effort and am the author of
_Computer Science Logo Style_, a trilogy of CS books for teenagers
[ http://www.cs.berkeley.edu/~bh/logo.html ].

[Jeff Read]

On Sun, Feb 14, 2010 at 9:30 AM, Brian Harvey <b...@cs.berkeley.edu> wrote:

> SICP is our first course for CS and EECS majors. We offer a "zeroth" course
> for people without programming background, also Scheme-based, using my book
> _Simply Scheme_ [ http://www.cs.berkeley.edu/~bh/ss-toc2.html ].

They had one of those when I was an undergrad, too. Of course, it
mainly just had basic DOS and Microsoft Office competency -- no
programming.

Anyway, I'm Jeff Read, and I got into Scheme round about the end of
the last millennium, when I discovered that my favorite program GIMP
supposedly had Scheme embedded in it. Of course it was SIOD, but soon
I found myself putting together Web sites with Guile, and then I got
hooked. The language's utter simplicity and boundless flexibility
induce me to seek out a solution in it first for any new problem. When
I got savvy enough to read the Lambda Papers and other hallmark papers
in Lisp lore, my mind was blown. I seek to uphold the Scheme tradition
of a minimal orthogonal core which spans the space of real programming
problems, yet recognize the need for more sophisticated, higher level
constructs and libraries for practical needs; for this reason (and the
fact that it has a precedent in C standardization) I wholeheartedly
supported the dual language standard. I decided to devote my efforts
to Thing One because my personal aesthetic tastes favor simplicity
over elaboration and convenience.

Oftentimes my final professional work product cannot be written in
Scheme, but it remains a useful tool for difficult problems which
skirt the bounds of tractability in other languages. These days my
personal programming efforts involve sound and image processing
software in Scheme, as well as an activity for Scheme development in
the OLPC Sugar environment.

--Jeff

[Arthur A. Gleckler]

Here is what I wrote on my member page on the WG wiki at
<http://trac.sacrideo.us/wg/wiki/ArthurGleckler>:

I am a member of Working Group 1.

My home page is here: http://speechcode.com/

I love Scheme, and I do all my personal programming projects in
Scheme. I'm sneaking Scheme in here and there in side projects at
work, too.

Here's what I wrote to describe myself when I submitted my name to
vote on R6RS:

I've been an avid fan of Scheme since 1984, when I first used it
as part of the 6.001 Structure and Interpretation of Computer
Programs course at MIT. It has been my favorite programming
language since then, and while I rarely use it at work, I use it
for all my programming projects at home. While I was an
undergraduate, a staff member, and a graduate student at MIT, I
spent many years working on MIT Scheme, including its interpreter,
compiler, runtime system, debugger, and editor, and I continue to
make small contributions in my spare time. I've also spent a lot
of time working on my own unfinished implementation of Scheme. I
followed the R4RS and R5RS standardization processes closely,
participated some in the IEEE Scheme standardization process, and
have participated quite a bit by email in the R6RS process. I
want to help make sure that R6RS maintains the right balance
between the diamond-like jewel Scheme has always been and the
practical everyday programming language that we have always wanted
Scheme to be.

I'm looking forward to making the Scheme standard even better in this
round.

[David Rush]

The blurb I wrote for the Wiki:

My first exposure to Lisp was with LISP 1.5 in a Honeywell computer room, back in the days when disk packs walked, and drums were also for storage. Unfortunately it remained just a book on my shelf while I programmed through client-server and OO systems, and only really began to program in it to tweak my Emacsen and even better, SCWM. In the late 90s I was using SML/NJ for my home hacking but found that the time spent wrestling with perfecting the type structures of my programs was not giving me a good RoI in terms of functionality (even though they had much greater reliability), so I switched over to Scheme, first at home and later as a double secret power tool in industry.

I found Scheme to be nearly perfect for hacking, powerful, regular, forgiving, and small enough that I could leave a project aside for 3 months due to the pressures of work and resume it without missing a beat. This small mental footprint is an *essential* feature of Scheme for me, and I consider that the greatest work of WG1 will be in avoiding the multiplication of entities in achieving the goals in the charter. Finding paradigmatic fault lines is a difficult task, and creating compatible and stable structures to exploit them is even more so, but I think that will be necessary for Thing1 to meet the goals stated in the charter.

I do feel that I am academically and intellectually playing a bit outside of my league in this group. It is rare to find people of this caliber in industry, but I will do my best to keep up.

david

--
GPG Public key at http://cyber-rush.org/drr/gpg-public-key.txt

[Alaric Snell-Pym]

Alex Shinn wrote:

> It would be nice if everyone listed here can introduce
> themselves.

Hi! I'm Alaric Snell-Pym. I've been in love with Scheme since I got a
copy of SICP for my 16th birthday (fourteen and a half years ago now, if
you're interested). I've rarely had the privilege of using Scheme in my
work; due to the usual silly reasons, I usually have a hard time if I
suggest it ("..but Python/PHP/Perl/Ruby programmers are widely
available!", etc).

So my selfish motivation for being here is to try and engineer Scheme in
a direction that will let me get away with using it for work... without
falling into the trap of just turning it into Python/PHP/Perl/Ruby. I
know where they are if I want them.

I'm not an academic, but I'm considered rather academic by my colleagues
in industry... I'm the one they go to to ask for interesting algorithms,
complexity analyses, and the like ;-)

The way ahead I see is to turn the diversity of implementations into an
asset, by getting them interoperating better. So I want more code
portability; both of applications and of libraries. Library portability
is especially important, since the availability of good libraries is a
strong argument for a language to be used for "real programming"
(whatever that is). I see a *lot* of Scheme libraries out there; just
they're not very portable between implementations, so effort is wasted
re-inventing the wheel.

And yet the desire for portability needs to be balanced against the
ability to give implementations leeway to do new things. I *love* having
implementations that compile to C for standalone apps, or fast
interpreters that are easily embedded for an extension language, or that
are big interactive GUIs with fantastic debugging facilities for
learning and development. And I love that, many years ago, when my team
needed an extension language for a Java-based content management system,
we were able to implement most of Scheme ourselves in a week or two,
then pile on off-the-shelf code to implement a useful environment.
That's an *agility* that few other languages can match (FORTH being the
closest contender, and I wouldn't want to write large applications in
that...)

And how do I think this sort of portability and agility can be found? A
few general principles: a simple core makes for agility of
implementations, while a core that provides the tools to modularise
systems makes for library portability. That's why I like the idea of
parameters being in the core, so that library authors can use them
without fear, to make libraries that manage their mutable state in a
thread-safe way (and make for cleaner interfaces less cluttered with
rarely-modified default parameters, and not forcing libraries that use
those libraries to laboriously pass through a load of these
rarely-modified parameters from a higher-level caller...).

So on issues like case sensitivity, I'm not very vocal. As long as there
remains a coding standard that can be easily followed that will make
code portable, I think most code will use that standard.

I look forward to getting more into discussions about
libraries/packages/modules - mainly because I don't myself know the
right answer, and look forward to finding out what everyone's needs are,
and seeing how they can be met.

And, for the record, I welcome constructive criticisms of my ideas; I
will often raise ideas I'm not sure about myself, just to make sure they
get properly considered and rejected. I'm not precious about them - so
nobody should feel shy about telling me my ideas suck! Just try not to
imply that *I* suck...

ABS

--
Alaric Snell-Pym
http://www.snell-pym.org.uk/alaric/

[John Cowan]

I'm more of a programmer who knows Scheme (and lots of other languages)
than a Scheme programmer: I haven't written Scheme in anger, as
the saying is. But I do love Scheme. I've also put together a big
proposal for what I want to see in Thing One; feel free to read it at
http://tinyurl.com/thing-one and critique it. I'm also the resident
Unicode weenie and the chair of WG2.

--
De plichten van een docent zijn divers, John Cowan
die van het gehoor ook. co...@ccil.org
--Edsger Dijkstra http://www.ccil.org/~cowan

[Thomas Lord]

Hi,

My name is Thomas Lord.

Prior to my achieving fame and glory by calling upon
fellow WG1 members to introduce themselves on this
list:

I began learning to program in the early 1980s by
reading books and magazines, soon thereafter gaining
access actual computers. I programmed in many
languages and environments, often neglecting other
responsibilities for the opportunity to program
on these then-scarce machines. "Artificial Intelligence"
was a hot topic in the popular technical press of
the day and so I was drawn into learning Lisp.

In the late 1980s I learned of and about Scheme and
was concurrently contemplating various other then
hot topics in programming language design in relation
to my employment as a junior member of a research project
at a major university. I was also heavily in love with
(and still am quite fond of) the architecture of GNU
Emacs - and came to regard LAMBDA as the ultimate
extension language (I still retain the dream of a
Scheme-based Emacs the way I would want to do it).

In the mid 1990s I was privileged to have the job
opportunity to invent and initiate the GNU Guile project
but unlucky enough to have to cut my participation short
due to various nefarious actions by some of those around me.
You see, these various agents of the CIA and the military
intel community conspired to... no, wait.... that's a story
for a different day. Anyway, I was abruptly called away
from the GNU Guile project, much to my disappointment.

I've also done some interesting (arguably good) work in,
among other areas, regexp theory and implementation and
computational genomics. (The two fields converge in interesting
ways, as seems to be likley true of most any two deep
fields in C.S.).

In his recent introduction, Mr. Sussman remarked:

"For me a computer is an expressive instrument,
like a musical instrument. I program to express
thoughts in a way that can be unambiguously understood,
by both my electromagnetic and my biological friends.
Thus, for me, the most important value of a computer
language is that it be as expressive and as free
of unnecessary restrictions as is technically possible.

I also feel strongly that it is not my duty to tell
others how to program, and I don't want others to
legislate my style either."

I share that sentiment but also wish to add something:

In preliminary discussions, several WG1 members have
expressed a (quite reasonable, in many ways) sense of
conservatism - that we should not be anxious to change
the language(s) we have inherited or too quick to want to
add new features.

Unfortunately, this sentiment is sometimes expressed in
extreme ways. For example (and I am paraphrasing and
mashing up comments from multiple people here): someone
might say "We ought not standardize anything that is not
already widely implemented," or "Our job is not to invent
or design but to document what is already invented and
designed".

I say bull-hockey to that.

We need not be radical (whatever that means). We need
not re-invent the wheel and claim it as our own. But
we ought to be bold. Bolder than statements such as those
I paraphrased suggests.

We can invent and standardize whatever the heck makes
the most sense, and we should. One simple fact is that
the past several generations of revised reports on the
scheme programming language have *erred* on the side of
conservatism at the cost of recording less than we have
discovered about core Scheme while also *erring* on the
side of compromising by introducing cramped facilities
characterized by feature piling and unnecessary restrictions.
We should, at the very least, not be afraid to think through
and consider "new things" for the standard.

My ideal for the WG1 "Thing One" Standard is of a practical
core that is *smaller* than R5RS, yet more general, combined
with a specification of the rest of (something very close to)
R5RS expressed in that core. Additionally, my ideal for WG1
includes the concepts that:

1) Just implementing that "core" naively can yield
a useful implementation.

2) The tricks of the trade of non-naive R5 implementations
can be usefully descibed and derived from that core.

3) WG2 is basically just libraries atop what we build in
WG1.

Enough of this complex burble-er-verbal behavior... yadda yadda yadda
nice to meet y'all, etc. etc.

Regards,
-t

[Bradley Lucier]

Introductions, hmmm ...

I started programming in Fortran II on an old IBM 1620 at the University
of Windsor when I was 15. When in graduate school, I got from Jim Cody
a draft copy of Cody and Waite's text on the elementary functions, and
decided to apply Hoare's technique of program invariants to prove the
algorithms were correct. So I programmed it in Pascal after getting
frustrated trying to do it in Fortran.

While math graduate students, Dave Miller (now dean of the College of
Computing and Digital Media at DePaul University) and I started the
first three-course undergraduate sequence in computing at the University
of Chicago (programming in Pascal, algorithms and data structures, AI in
Lisp). My thesis was the first computer-typeset thesis at the
university (and troff took 1 CPU minute *per page* to format it on a VAX
11/780).

I like to compute. I learned C because the Fortran compiler for the
Denelcor HEP was so bad that I couldn't get good performance
measurements of a parallel algorithm I was developing. I learned C++
because it was too hard in C to program an image-compression algorithm
and thread together the bit-stream outputs of a bunch of (conceptually
parallel) arithmetic coders into a single file.

So basically I learned a new language whenever the ones I already knew
got in the way of what I was trying to do.

I started with MacGambit sometime in the spring of 1993, while Marc
Feeley was still a graduate student at Brandeis, using it to work
through SICP. From then I've used Scheme for all my projects. I've
never felt a need to learn another language, or that Scheme was
interfering with what I was trying to do. Among the larger projects
I've worked on are a rewrite of Gambit's bignum code, a
homework-on-the-web system for a class on trigonometry, and a system for
the finite-element method for partial differential equations in two
dimensions.

I want WG1 scheme to be the language I use to get things done,
especially to develop new algorithms for various problems. I want to
re-implement Meroon to use a hygienic macro system and modules because I
see the kind of problems introduced by define-macro plus Meroon's ad-hoc
code walker. I want to continue to do numerical programming in Scheme.
I don't want to overburden myself learning new things---someone said
that a mathematician is a person who forgets as much as possible,
basically anything that can be reconstructed, so WG1 Scheme appeals to
me.

There were a lot of "I"s in the preceding paragraphs, but I suppose
that's the nature of introductions ...

Brad

[Alexey Radul]

I volunteered for this working group because Scheme has made my life
unbearable. Scheme is so bad that I can't bear to work in it, and yet
Scheme is so good that I can't bear to work in anything else either.
For half of my (admittedly not very long) career, Scheme's uniformity
and elegance have given my mind wings on which I have soared above the
highest peaks, but Scheme's balkanization and non-interoperability
have trapped me in the deepest dungeons. So I hope that I can
contribute to standardizing the right base on which a garden of
portable libraries can blossom.

Cheers,
~Alexey

[Steven Ganz]

I posted this to the wiki, but will send it out here too.

I'm happy to have this chance to participate in the latest Scheme standardization process.

My first exposure to functional programming was CSE121,  written about by Joel Spolsky (it was then taught in Franz Lisp). It definitely influenced how I approached programming, but it wasn't until I started graduate school at Indiana University that I was exposed to Scheme by Daniel Friedman and really dove in. I ended up doing my doctorate under him and certainly benefited from his strong intuitions. My research interests have centered around modeling effects in functional programs (whether state, multithreading, or logic programming), although I've also been interested in macro expansion. I'm currently coauthoring with Dan the next book in the "Little Schemer" series.

I've been lucky to be able to use Scheme at two startups in Silicon Valley. Although it was never the only language used, its expressiveness was a great asset in implementing complex processing. This gives me a practical perspective that balances the research-based one.

I'd like for Scheme to be the only language I need for prototyping ideas, getting things done quickly. In my opinion, the most essential characteristic of Scheme that we should strive to preserve is its simple but powerful operators. I'd like for a guiding principle to be not to design in a vacuum, but to leverage directly off of experience with the great language that we have been given. That means being motivated by real examples of: 1) the reasonably few instances where Scheme falls short in expressing a programmer's intent and 2) difficulties in reusing code across implementations.

You can see more about me at  my home page.

Steve

[Patrick Durusau]

Greetings!

Sorry for the delayed introduction. I was waiting for the initial rush
of posts, counter-posts and other normal activity of a new group to
subside before posting. ;-)

I came to computers and programming in a round about way. After a
misspent youth as they say (legal practice for ten years), I went back
to graduate school in biblical studies and discovered that I could not
enter cuneiform on a Commodore 128. :-( That was shortly after SGML
became an ISO standard and so began a long sojourn with various markup
languages, including TEI and more recently Open Document Format.

Over the past decade that I have worked with topic maps as a semantic
technology, I have become interested in the underlying decisions about
technologies that lie just beyond discussion. I do a fair amount of
reading on early computer science and information retrieval where
current orthodoxies were only some of the choices that could have been made.

I am interested in Scheme because of its lack of "second class citizens"
bears a striking resemblance to aspects of my work in topic maps.

I am interested in WG1 because of my work as a standards editor and look
forward to broadening my experience with the standards process as part
of this group.

Hope everyone is looking forward to a great weekend!

Patrick

--

Patrick Durusau
pat...@durusau.net
Chair, V1 - US TAG to JTC 1/SC 34
Convener, JTC 1/SC 34/WG 3 (Topic Maps)
Editor, OpenDocument Format TC (OASIS), Project Editor ISO/IEC 26300
Co-Editor, ISO/IEC 13250-1, 13250-5 (Topic Maps)

[Robert]

On Feb 13, 10:11 pm, Alex Shinn <alexsh...@gmail.com> wrote:
> It would be nice if everyone listed here can introduce
> themselves.

I'm Robert Smith.

I've had an intense interest in lisp (note that when I say 'lisp', I
speak of the lisp/scheme family of languages, no particular dialect)
for quite some time. I have implemented three generations of a
programming language I call "Delta", which is no longer developed and
it was never publicly released, just to a few friends. It was very,
very similar to Scheme, except some cosmetic changes to some keywords
("do" instead of "begin", easier ways to create lambda functions), as
well as a built in way to handle object oriented programming, as well
as the inclusion of modules. Anyway, I've also been interested in
lisps from a theoretical standpoint, and began authoring something I
call "lisp math", which attempts to explain some lisp concepts from a
more mathematical point-of-view.

For some time, I have moved my focus on lisp to include a wider scope
and have been exploring type systems, pattern matching, and many of
those goodies seen in more purely functional languages. As a hobby, I
am in the process of designing a language for doing mathematics, as
well as general programming. With that said, I really like theory
behind languages. I am also an avid "mathematician" (quotes to imply
that I'm not actually one, but I do fair bit of mathematics), and I
often think imposing mathematical structure on programming languages
is beneficial.

I have programmed considerably in C, Scheme, Common Lisp, Standard ML,
Haskell, Fortran 90/95/2003, my programming languages Delta/Rho/
Mirrion; C++ :-( , computer algebra systems Mathematica/Maple/Axiom/
Maxima, and others.

My programming interests besides language implementation (compilers,
interpreters) include symbolic programming, numerical programming/
analysis (I have implemented a library for arbitrary precision
floating-point arithmetic for many algebraic and transcendental
functions), genetic and evolutionary programming, optimization,
automation, ... and the list goes on. Mathematical interests include
the theory of special functions, analytic number theory, discrete
analytic functions, computational complexity and asymptotics, abstract
algebra, type theory, decision procedures and decidability, ... and
this list goes on too.

Aside from programming and mathematics, I love writing and typography,
especially mathematical. I am writing a book on algebraic and symbolic
programming in parallel to my design and implementation of the
aforementioned language. I consider myself fairly competent with
LaTeX, and very much enjoy writing it. So it would be my pleasure to
get things looking good in LaTeX for things we write/decide/etc. here.

My interest in being in the working groups isn't so easy to state. I
wish to be an active participant in much of the design decisions of
the WG1 and WG2 languages. I am hoping I can provide insight or views
or ideas, with heuristic or rigorous reasoning, on what changes maybe
should be made and how things should work. I also hope to maintain a
certain consistency in the languages while achieving a good level of
practicality, which I have like a lot about Scheme compared to, say,
Common Lisp. Lastly, I hope I can write things representing our work
in a presentable, even publishable-quality, way.

So, this wasn't so brief, but if a brief version is needed:

Robert Smith, a programming, mathematics, and technical writing
hobbyist. Implemented several languages (compiled and interpreted),
including a strongly, statically typed language with a very extensible
type system, as well as incredibly Scheme-like languages. Implemented
arbitrary precision arithmetic in C including very fast algorithms for
many operations. Interests in helping WG[12] include giving it a
mostly formal foundation, making ideas concrete in writing, and
providing insight and constructive criticism of ideas and proposals.