Archive for the ‘Scheme’ Category

SICP [In Modern HTML]

Monday, April 18th, 2016

SICP by Andres Raba.

Poorly formatted or styled HTML for CS texts is a choice, not a necessity.

As proof I offer this new HTML5 and EPUB3 version of “Structure and Interpretation of Computer Programs” by Abelson, Sussman, and Sussman.

From the webpage:

Modern solutions such as scalable vector graphics, mathematical markup with MathML and MathJax, embedded web fonts, and syntax highlighting are used. Rudimentary scaffolding for responsive design is in place, which adapts the page for viewing on pocket devices and tablets. More tests on small screens are needed to adjust the font size and formatting, so I encourage feedback from smartphone and tablet owners.


SICP Distilled Now Public

Thursday, October 8th, 2015

SICP Distilled Now Public by Tom Hall.

From the post:

I have made the SICP Distilled site public.

It is now a year since the SICP Distilled Kickstarter was funded, I originally thought it would take 5 months to complete and had a slightly different vision for what it would look like, massive thanks to all of the supporters for their patience and understanding.

I originally thought an accompaniment to the original book but it has wound up being more like a rewrite, fortunately the original text is under a Creative Commons Attribution-ShareAlike 4.0 License so I can ‘remix’ it without getting into copyright issues if I have the same licence.

It is not complete yet, but I think I now have good explanations of:

Which really are (for me at least) the highlights of the book.

As a very minor supporter in the Kickstarter campaign I deeply appreciate all the effort that Tom has devoted to this effort.

Comment early and often!

The Concert Programmer

Saturday, November 8th, 2014

From the description:

From OSCON 2014: Is it possible to imagine a future where “concert programmers” are as common a fixture in the worlds auditoriums as concert pianists? In this presentation Andrew will be live-coding the generative algorithms that will be producing the music that the audience will be listening too. As Andrew is typing he will also attempt to narrate the journey, discussing the various computational and musical choices made along the way. A must see for anyone interested in creative computing.

This impressive demonstration is performed using Extempore.

From the GitHub page:

Extempore is a systems programming language designed to support the programming of real-time systems in real-time. Extempore promotes human orchestration as a meta model of real-time man-machine interaction in an increasingly distributed and environmentally aware computing context.

Extempore is designed to support a style of programming dubbed ‘cyberphysical’ programming. Cyberphysical programming supports the notion of a human programmer operating as an active agent in a real-time distributed network of environmentally aware systems. The programmer interacts with the distributed real-time system procedurally by modifying code on-the-fly. In order to achieve this level of on-the-fly interaction Extempore is designed from the ground up to support code hot-swapping across a distributed heterogeneous network, compiler as service, real-time task scheduling and a first class semantics for time.

Extempore is designed to mix the high-level expressiveness of Lisp with the low-level expressiveness of C. Extempore is a statically typed, type-inferencing language with strong temporal semantics and a flexible concurrency architecture in a completely hot-swappable runtime environment. Extempore makes extensive use of the LLVM project to provide back-end code generation across a variety of architectures.

For more detail on what the Extempore project is all about, see the Extempore philosophy.

For programmers only at this stage but can you imagine the impact of “live searching?” Where data structures and indexes arise from interaction with searchers? Definitely worth a long look!

I first saw this in a tweet by Alan Zucconi.

SICP Distilled (Clojure)

Thursday, August 28th, 2014

SICP Distilled (Clojure) by Tom Hall.

Tom has started a Kickstarter campaign to finance the authoring of a Cloure-based companion to SICP.

A companion which Tom describes as:

As the book [SICP] itself is available online for free I want to make the perfect accompaniment to it – an ebook summarising the key ideas, short videos describing them, screencasts of solving some of the exercises, translation of the examples into Clojure, example projects, partial solutions for you to complete (similar to 4clojure and Clojure koans) and a place to discuss solving them with people.

Project will be funded on Tue, Sept. 16, 2014 4:12 EDT.

This should be enough notice for even the most disorganized of us to pledge in support of SICP Distilled (Clojure).

Please pass this along, tweet, re-post, etc.

Oleg Kiselyov’s Homepage

Friday, July 11th, 2014

Oleg Kiselyov’s Homepage

A very nearly plain text homepage that covers:

Algorithms and Data Structures Computation
Continuations Essays
Haskell Image Processing
Lambda-calculus Linguistics
Logic Meta-programming
ML Non-determinism
Numerical Math OS
Probabilistic Programming Programming Languages
Scheme Types


Should be near the top of any seed list for searching on functional programming, Haskell, Scheme, etc.

SICP Distilled

Sunday, July 6th, 2014

SICP Distilled

From the webpage:

An idiosyncratic tour of the best of SICP in Clojure.

Have you always wanted to read SICP but either didn’t start or gave up mid-way?

Take a few days to experience a distillation of its most important lessons.

Followed by a sign-up form.

Don’t know any more than that but it is an interesting concept.

If and when I get more details, I will post that information.

Structure and Interpretation of Computer Programs (SICP)

Saturday, June 21st, 2014

Structure and Interpretation of Computer Programs (SICP) by Abelson & Sussman.

Already available from MIT Press for free, SICP is available here with newly typeset mathematics and figures.

You will find Kindle versions as well.

A truly remarkable addition to e-texts in computer science would be TAOCP. Somehow I don’t think that is going to happen anytime soon.

I first saw this in a tweet by thattommyhall.

SICP in Clojure

Sunday, December 1st, 2013

SICP in Clojure by For reasons unknown, the maintainer posted a link to Steve Deobald as the maintainer. Sorry Steve!

From the webpage:

This site exists to make it easier to use Clojure rather than Scheme while working through SICP. The folks behind SICP were kind enough to release it under a Creative Commons Attribution-Noncommercial 3.0 Unported License, which will allow me to annotate the text and adapt its source code and exercises to fit the Clojure language.

Structure and Interpretation of Computer Programs, or SICP, is widely considered one of the most influential texts in computer science education. If you believe Peter Norvig, it will change your life. MIT Scheme, a minimalist dialect of Lisp, is used for all code examples and exercises.

Clojure is a “modern” Lisp that runs on the Java Virtual Machine. Its speed, easy access to Java libraries, and focus on concurrency make it an appealing language for many applications.

This site exists to make it easier to use Clojure while working through SICP. The folks behind SICP were kind enough to release it under a Creative Commons Attribution-Noncommercial 3.0 Unported License, which will allow me to annotate the text and adapt its source code and exercises to fit the Clojure language.

All credit, of course, belongs to the authors: Harold Abelson and Gerald Jay Sussman, with Julie Sussman.

As you will find at the status page, there is much work left to be done on this remarkable project.

Any thoughts on how to move this project forward? Such as having the real maintainer stand up?

Structure and Interpretation of Computer Programs (Python)

Tuesday, November 1st, 2011

Structure and Interpretation of Computer Programs (Python)

The classic Scheme based text by Abelson and Sussman taught with Python code. (lecture notes too)

Revised Report on the Propagator Model

Sunday, October 30th, 2011

Revised Report on the Propagator Model by Alexey Radul and Gerald Jay Sussman.

After I watched Sussman’s We Really Don’t Know How To Compute!, I just had to track down more information on the propagator model!


In the past year we have made serious progress on elaborating the propagator programming model [2,3]. Things have gotten serious enough to build a system that can be used for real experiments.

The most important problem facing a programmer is the revision of an existing program to extend it for some new situation. Unfortunately, the traditional models of programming provide little support for this activity. The programmer often finds that commitments made in the existing code impede the extension, but the costs of reversing those commitments are excessive.

Such commitments tend to take the form of choices of strategy. In the design of any significant system there are many implementation plans proposed for every component at every level of detail. However, in the system that is finally delivered this diversity of plans is lost and usually only one unified plan is adopted and implemented. As in an ecological system, the loss of diversity in the traditional engineering process has serious consequences.

The Propagator Programming Model is an attempt to mitigate this problem. It is a model that supports the expression and integration of multiple viewpoints on a design. It incorporates explicit structure to support the integration of redundant pieces and subsystems that solve problems in several different ways. It will help us integrate the diversity that was inherent in the design process into the delivered operational product.

The Propagator Programming Model is built on the idea that the basic computational elements are autonomous machines interconnected by shared cells through which they communicate. Each machine continuously examines the cells it is interested in, and adds information to some based on computations it can make from information from the others. Cells accumulate information from the propagators that produce that information. The key idea here is additivity. New ways to make contributions can be added just by adding new propagators; if an approach to a problem doesn’t turn out to work well, it can be identified by its premises and ignored, dynamically and without disruption.

This work was supported in part by the MIT Mind Machine Project.

I really like the idea of additivity. I think it has long legs in a world characterized by diversity. That is to say a world outside most programming paradigms, which presume a syntax, semantics and inviolate rules, the very opposite of diversity.

Write Yourself a Scheme in 48 Hours

Monday, October 3rd, 2011

Write Yourself a Scheme in 48 Hours

From the webpage:

Most Haskell tutorials on the web seem to take a language-reference-manual approach to teaching. They show you the syntax of the language, a few language constructs, and then have you construct a few simple functions at the interactive prompt. The “hard stuff” of how to write a functioning, useful program is left to the end, or sometimes omitted entirely.

This tutorial takes a different tack. You’ll start off with command-line arguments and parsing, and progress to writing a fully-functional Scheme interpreter that implements a good-sized subset of R5RS Scheme. Along the way, you’ll learn Haskell’s I/O, mutable state, dynamic typing, error handling, and parsing features. By the time you finish, you should be fairly fluent in both Haskell and Scheme.

Functional programming is gaining ground. Are you?