Slide40 – Presentations with 8-bit style

Slide40 is a program for displaying slide presentations in a style inspired by the personal computers of the late 1970’s. The display mimics a TV screen showing only 40 columns of text in an all-caps font built from big blocky fuzzy pixels. I created it partly as a joke, and partly as a minimalist artistic reaction to the highly-decorative but meaningless presentations made by abusers of modern presentation software.

HOP Web Framework

HOP is a new Software Development Kit for the Web 2.0. It relies a new higher-order language for programming interactive web applications such as multimedia applications (web galleries, music players, …), office applications (web agendas, mail clients, …), ubiquitous domotics, etc. HOP can be viewed as a replacement for traditional graphical toolkits. HOP is implemented as a Web broker, i.e., a Web server that may act indifferently as a regular Web server or Web proxy.

(via comp.lang.scheme)

Commercial Uses of Functional Programming

Commercial Use articles focus on functional programming “as a means, not an end”. As such, we solicit papers about experiences using functional languages in commercial and open source settings. The purpose of a Commercial Use article is to document and assess cases where functional programming was used in a real world setting. We are interested not only in successes, but also in failures. Articles should distill experiences using functional languages so that others can learn from those experiences, whether the lessons learned be technical, organizational, or about the narratives used to make the case to management.

(via CUFP)

Remove .svn files recursively

Today I needed to convert a Subversion working copy (aka a checkout) into an export. Recursively blowing away all of the .svn directories in DOS (Windows XP) didn’t seem to be straightforward so I ended up using UNIX find in cygwin. Here is the command:

find . -type d -name '.svn' -exec rm -rf {} \;

The command was provided here, and the following is documentation from the man page.

  • find :: Execute the find command
  • . :: Path in which to start
  • -type d :: File is of type ’d’, a directory.
  • -name ’.svn’ :: The file name on which to match, .svn.
  • -exec rm -rf {} \; :: Execute this command for every file that is found. The string ’{}’ is replaced by the current file name being processed. The semi-colon is escaped by a backslash. While reading the man page, I also found that you probably should enclose the braces in single quote marks.

HtDP: Problem 9.5.5

In problem 9.5.5, I knew I wasn’t understanding something. I thought that I had followed the recipe, yet I couldn’t solve the problem. That alone was a red flag indicating that I most probably did not follow the recipe!
In this discussion everyone helped me to see what I was missing. The thing was that I was missing something about recursion, the fact that you can figure out what you need to do by combining this thing with the rest of the things.
To specific, the step that I had skipped was literally taking the expected data and using that to determine the combination that needs to occur within the program body. Before, my approach had always been to solve “the whole problem” at once for the recursive step. Following the recipe, you can much more easily see what you are missing.

HtDP: Problem 10.1.9

In problem 10.1.9, I wanted to force a problem to be recursive when it really wasn’t. Matthias and Carl helped me see the difference here in the discussion that followed. Here are some notes:
Matthias:

In HtDP, the word “natural” is a technical word. It means
if your INPUT data definition has a self-reference in the Nth clause for the Kth field then your template has a recursion in the Nth cond clause for the Kth field.
Try this:
An RD is one of:
— ‘doll
— (cons RD empty)
Problem: design a function that counts the number of cons layers around ‘doll.

Carl:

what’s so recursion about it? To be less cryptic, if you read your purpose statement, and apply it to the recursive call, does it make sense? Are you really solving a smaller instance of the same problem, or are you just solving a smaller problem? The former is recursion; the latter is not (and suggests either inlining or a helper function).
For future reference, what I described is a way to tell after the fact whether what you wrote makes sense as recursion, but what Matthias described is the part of the design recipe that tells you whether to use it or not before you even start. Focus on what he said (and what’s in the book) for figuring out how to apply recursion, and you’ll find you can always answer what I asked with “yes”.