Framework

The first step was to survey the current crop of HTML5/CSS/Mobile frameworks. Leading the pack is html5-boilerplate. This is a full-site solution, including things like a .htaccess with smart defaults and a build script that automatically optimizes html/css/js/images for the web. It has decent documentation, including several videos which I couldn’t bring myself to sit through, so I just dove in and started working.

Obtain html5-boilerplate from GitHub and create a branch for your site. The GitHub version is up-to-date and branching makes it easier to merge future updates. My branch is called “homepage”.

git clone https://github.com/h5bp/html5-boilerplate.git
git checkout -b homepage

Content and Styling

The main files you’ll modify for a simple static site are index.html, css/style.css, all the favicon-y images, and humans.txt. For index.html be sure to add your information to the title and description tags and modify the Google Analytics id section.

The CSS is based on progressive enhancement, where the default CSS is minimal and targeted at a low-resolution and bandwidth mobile device. This is the first section of CSS in style.css, and then for larger-screen devices (presumably with more bandwidth and processing power) you later introduce extra styling in the @media sections.

My site has a top-to-bottom linear layout of all items by default. As the browser window width increases, an image is floated alongside the text and we accept the extra overhead of loading a background image tile. I chose the background from the site Subtle Patterns and the color pallet with the help of Color Scheme Designer.

Publish

When the site is ready to go, use the ant build script to generate the web-optimized site. This will create a publish/ directory that is ready to be placed on the server. On Ubuntu, the build required the Oracle JDK, rather than the OpenJDK that comes installed by default, to avoid seeing an error message.

I wanted to manage deployment via git, so that I would have an fast way to rollback changes and that didn’t require re-building the site. I created a git repository in the publish directory (it is .gitignore‘d by the parent project) and pushed it to my remote server. On the server, I cloned the repository directly into my web directory. The html5-boilerplate .htaccess prevents access to dotfiles, so the .git information is safe. I use the hash from the development repository branch for the commit message in the publish repository.

Unfortunately, by default, the html5-boilerplate build script deletes the publish directory, wiping out the git publishing repository. To fix this, I replaced the line in build.xml:

<delete dir="./${dir.publish}/"/>

with:

<delete dir="./${dir.publish}/" includeemptydirs="true" defaultexcludes="false">
<exclude name=".git/**" />
</delete>

Workflow

The process for updating my webpage is:

1. Make changes to development branch
2. ant minify
3. local: git add/commit/push
4. remote: git pull

srt(X,Y) :- permutation(X,Y), isSrt(Y).

isSrt([]).
isSrt([_]).
isSrt([H,I|J]) :- H=<I, isSrt([I|J]).

The beauty of this solution is that Prolog does all the dirty work of finding a sorted Y for our given X. The darker side is that Prolog’s satisfaction mechanism carries out a brute force search through all possible permutations of the given list. This is dangerous; compare the runtimes of our naive sort and the Prolog built-in sort (which is decidedly less naive):

% 5 seconds vs. something < 0.01 seconds
reverse([1,2,3,4,5,6,7,8,9,10],X), profile(srt(X,Y)).
reverse([1,2,3,4,5,6,7,8,9,10],X), profile(msort(X,Y)).

Not great, and notice how fast the worst case time of O(n!) grows:

% 55 seconds vs. something < 0.01 seconds
reverse([1,2,3,4,5,6,7,8,9,10,11],X), profile(srt(X,Y)).
reverse([1,2,3,4,5,6,7,8,9,10,11],X), profile(msort(X,Y)).

This is to be expected; if we want to be picky about how the job gets done, we can be more explicit in our description. So let’s ignore performance and and see how to write a declarative “permutation” predicate from scratch.

Ugly Permutations

Skip this section unless you’re interested in how a simple idea is translated into a complex and unattractive Prolog solution.

One descriptive definition of a permutation of a list: each item in the given list is in the permutation and each item in the permutation is in the list.

I started by trying to define a membr/2 predicate such that it would succeed when all items in the first list are in the second list. Attempts at extending this into something that would produce permutations caused infinite loops and stack overflows until I settled on this definition:

membr([H|T],Y) :-
    length(Y,L), length(T,M), M<L,
    member(H,Y), membr(T,Y).
membr([],Y) :- allNonVar(Y). 

allNonVar([]).
allNonVar([H|T]) :- nonvar(H), allNonVar(T).

srt(X,Y) :- membr(X,Y), isSrt(Y), !.

Where member/2 is a built-in predicate with a straightforward Prolog implementation.

The clauses dealing with length prevent len(Y) < len(X) if X contains duplicates. The predicate allNonVar/1 prevents Y from having extra, un-unified anonymous variables. These can be left unbound when Y is forced to be a certain length, but duplicates in X always match to the first occurrence of the duplicate value in Y. These can also be left unbound when the member/2 goal posits extra anonymous variables; membr(X,[Y|_junk1,_junk2]) would otherwise be true.

Finally, the cut at the end of srt/2 prevents the consideration of equivalent permutations of the input list when it contains duplicates.

Pretty Permutations

The implementation of a simple definition of permutation ended up looking rather ugly because it had to fight the Prolog search mechanism.

A prettier implementation of a permutation predicate is given in Clocksin and Mellish, Programming in Prolog, Springer, 2003:

perm([],[]).
perm(L,[H|T]) :-
    append(V,[H|U],L),
    append(V,U,W),
    perm(W,T).

This states that a permutation of L is something that has as its head an element H drawn from L, and which is followed by something that is a permutation of the remaining elements of L.  Most of the permutation definitions on the web are built like this one, but I like its use of append/3.

This blog post sketches how QuickSelect and QuickMedian work in general and in my Java implementation. The bulk of the post discusses the plot of QuickMedian vs. SortMedian’s runtime shown below (click the image for more details).

QuickSelect Efficiency

QuickSelect uses the partitioning step of QuickSort to divide an array into two sections around a pivot.  All elements smaller than the pivot move before the pivot and all elements larger than the pivot move after the pivot.  A new pivot is chosen on the side of the partition that will contain the N-th element, and the partitioning step is run again.  It turns out that the number of elements visited on successive iterations of partitioning decreases so quickly in the average case that the overall runtime is expected , although worst case is .

QuickMedian Implementation

QuickMedian was originally intended to be a demonstration of the QuickSelect algorithm.  It turns out to be surprisingly tricky to write a robust median function!  Much of the trouble comes from handling even-length arrays in the case of large or infinite values.  When an array is of even length and the middle two values have large magnitudes, we need an averaging formula that avoids overflow.  When the middle two elements are infinity, in some cases we must return NaN.

Presenting arrays containing NaN to QuickSelect produces undefined behavior, which seems like the correct behavior.  What seems like incorrect behavior is present in Numpy, where NaN sorts before other values.  Here, the median value of a list can be decreased by inserting things which are not even numbers! Incorrect behavior may also result from a median calculation that uses Python’s native list sort() method.  Here, NaN is not ordered with respect to other numbers, so the median of an array can change from call to call!

The final problem faced by QuickMedian was one of inefficiency. Even-length arrays require two calls to QuickSelect to find the middle two elements. This is inefficient if implemented naively, because the two calls operate independently over the full array.  It should not be the case that runtimes vary greatly between arrays of length 1,000,000 and 1,000,001. To improve performance, QuickSelect was refactored to return the array indexes defining the smallest partition found that contains the N-th element. This partition is usually very small, and so the second QuickSelect call over this sub-array has negligible cost.

QuickMedian versus SortMedian

I wanted to examine the performance of QuickMedian, prove that it worked better than the sorting median method, and analyze the effects of different pivot picking methods.  The wall clock time was accumulated over the course of several randomized trials, divided and sorted carefully, then plotted.

Method

The evaluation consisted of 100 repetitions of trials in which several conditions were exhaustively varied.  In each trial, the median methods processed a total of 1e6 elements, which were divided up into arrays of constant length.  This number of elements was used because processing just one array of length 1000 was too quick to measure using the wall clock system time on my machine.  The conditions which were varied across trials were:

• Length of arrays into which the 1e6 elements were divided
• Even or odd-length arrays
• Sorting of the arrays: random, sorted, reverse-sorted, mostly-sorted, mostly-reverse-sorted
• QuickSelect pivot-picking method: middle, random, median-of-three, median-of-randomized-three
• Whether the arrays contained duplicates

Analysis

The runtimes were divided into series and sorted in such a way as to show interesting systemic effects.

Sorting by array length addressed the main question of computational complexity and runtime speed.  The QuickMedian runtimes remain roughly constant, while the SortMedian runtimes increase.  Remember that the elements in each trial are divided into arrays each of length such that .  QuickMedian has an expected runtime of , which is and thus expected to be constant across trials.  SortMedian has an expected runtime of which is expected , which is expected to increase as the array length increases!  The array lengths grow exponentially (something like 1e2, 1e3, 1e4, and 1e5), so the runtimes increase linearly.  This, and the fact that QuickMedian’s runtimes lie well-below most of the SortMedian runtimes)  is perhaps the central finding of the evaluation.

Then, splitting by the most interesting intra-algorithm condition showed further systemic effects.  The runtimes from the QuickMedian algorithm were divided into series based upon the pivot picking method used, while the SortMedian runtimes were divided by how the array was initially sorted.

The SortMedian results show that my platform’s Java sorting algorithm works fastest on reverse-sorted arrays.  The ripples in these series are interestingly due to the presence or absence of duplicates.

The QuickMedian results confirm that the fastest runtime is given by the deterministic pivot picking methods on sorted arrays, where the middle element is almost immediately found.  I was surprised to see that the randomized median-of-three pivot picking method never outperforms the deterministic median-of-three pivot picking method.  However, it makes sense because median-of-three killer sequences are probably unlikely.  I haven’t looked into this behavior yet, but I am assuming that the randomized median-of-three pivot picking method is more resistant to naturally-occurring killer sequences, so it will remain the default pivot picking method in QuickMedian.

Conclusion

A farmer was planting to reap,
Wished to profit the max on the cheap.
Trade-off soil, spacing, and blight,
Planting time, market value, and light,
But: too-complex his goals were to meet.

“Perhaps I can ask my dear friends,
To plant blindly what I recommends.
Select crops and place them by chance,
Grow, harvest, and then sell those plants.
The free market enforces the trends!

Some will make it and some will not,
Dupe success in the fallow lot,
But to all I’ll suggest
To mingle, and for zest,
To randomly swap partial plots.

Farmhands are a hard working breed.
They plant and they tend and they weed.
While it may be rarer,
A job done in error,
Begats a season novelty’d.

Perhaps not me nor my son,
Nor his daughter nor boss ADM,
But eventually one day,
The min work for max pay
Will pervade, then we’re finally done!”

The one-liner below is overkill for this task, but the extra arguments provide a starting point for modification for related tasks.  The use of find/xargs should help the one-liner deal with very large numbers of audio files and filenames that contain whitespace.

Code

find . -maxdepth 1 -name '*.wav' -type f -print0 | xargs -0 -t -r -I {} sox {} -r 8000 8000Hz/{}

Explanation

An explanation of commands and flags from left-to-right:

find .

searches the current directory subtree

-maxdepth 1

excludes subdirectories

-name '*.wav' -type f

outputs files that match the glob *.wav

-print0

first step in handling filenames with spaces

xargs

executes a command given the output of find

-0

second step in handling filenames with spaces

-t

prints on stdout the command that is to be executed

-r

runs SoX command iff find output is generated

-I {}

specifies the pattern “{}” is replaced by the output of find


sox {} -r 8000 8000Hz/{}

is the resampling command

I also generated a new, full set of adaptation prompt data from the CMU ARCTIC prompts.

Build SphinxBase

First download and build SphinxBase.  Since I had a relatively new Ubuntu install, I had to sudo apt-get install autoconf libtool bison.

svn co https://cmusphinx.svn.sourceforge.net/svnroot/cmusphinx/trunk/sphinxbase
cd sphinxbase
./autogen.sh
./configure
make
make check
sudo make install
sudo ldconfig -v

Thank you to Mnemonic Place for figuring out the last step (with ldconfig).  Without this, you’ll see errors when trying to run the sphinx_fe command, later.

Build SphinxTrain

svn co https://cmusphinx.svn.sourceforge.net/svnroot/cmusphinx/trunk/SphinxTrain
cd SphinxTrain
./configure
make

Record Adaptation Training Data

Record/obtain the 20 Arctic WAV files that are used in the CMU howto. Because the Communicator acoustic model is 8kHz, I recorded the WAV’s as 8kHz, 16-bit in Audacity and used the “multiple export” function to batch save. I rename‘d them to match the format that is compatible with their howto, e.g., “arctic_0001.wav”.  (Not quite as much fun as the Dave Barry passage that you get to read during Dragon’s adaptation process :] )

Miscellaneous File Downloading/Arranging

Download the four howto training files from the CMU wiki page.  One of the files is listed as “arctic20.fileids” but saves as “arctic20.listoffiles”; I just renamed it to “arctic20.fileids” so as to not cause confusion with later scripts and instructions.  If you need more than 20 prompts for adaptation, you may like to draw them from the full set of CMU ARCTIC prompts I generated.

Now move the four training files, your 20 arctic WAV files, the acoustic model you’re going to use to one directory.  My acoustic model is in a subdirectory named Communicator_40.cd_cont_4000/.  In my case, that one directory is a sibling of the sphinxbase and SphinxTrain directories.

Generate Features

sphinx_fe -argfile Communicator_40.cd_cont_4000/feat.params \
   -samprate 8000 -c arctic20.fileids -di . -do . \
   -ei wav -eo mfc -mswav yes

Gather Statistics

First copy over binaries from SphinxTrain:

cp ../SphinxTrain/bin.i686-pc-linux-gnu/bw .
cp ../SphinxTrain/bin.i686-pc-linux-gnu/map_adapt .
cp ../SphinxTrain/bin.i686-pc-linux-gnu/mk_s2sendump .

Find a copy of the “fillerdict” you use and copy it to the acoustic model directory, renaming it to the filename “noisedict”.

Run the Baum-Welch program:

./bw \
   -hmmdir Communicator_40.cd_cont_4000 \
   -moddeffn Communicator_40.cd_cont_4000/mdef \
   -ts2cbfn .cont. \
   -feat 1s_c_d_dd \
   -cmn current \
   -agc none \
   -dictfn arctic20.dic \
   -ctlfn arctic20.fileids \
   -lsnfn arctic20.transcription \
   -accumdir .

Perform MLLR training

Note that MLLR isn’t supported in Sphinx 4, so skip this step. “The Heiroglyph” document makes a point that you can iteratively build the mllr_matrix by running bw, then mllr_solve, then bw, then mllr_solve, etc. If you’re using a system that can take advantage of the mllr_matrix, you can run bw after you have your final mllr_matrix to generate MLLR-adapted statistics for the MAP adaptation described later.

cp ../SphinxTrain/bin.i686-pc-linux-gnu/mllr_solve .
./mllr_solve \
   -meanfn Communicator_40.cd_cont_4000/means \
   -varfn Communicator_40.cd_cont_4000/variances \
   -outmllrfn mllr_matrix -accumdir .

When the mllr_matrix exists, you can re-calculate statistics as mentioned above with the command:

./bw \
   -hmmdir Communicator_40.cd_cont_4000 \
   -moddeffn Communicator_40.cd_cont_4000/mdef \
   -ts2cbfn .cont. \
   -feat 1s_c_d_dd \
   -cmn current \
   -agc none \
   -mllrmat mllr_matrix \
   -dictfn arctic20.dic \
   -ctlfn arctic20.fileids \
   -lsnfn arctic20.transcription \
   -accumdir .

Perform MAP training

Sphinx4 can benefit from MAP training, but it is labor-intensive at the moment. MAP training requires accurate transcripts of the adaptation prompts, and may degrade performance if the wrong dictionary pronunciation is used for an audio recording. For example, there are two pronunciations for “a” in the cmudict: “uh” and “ay”. Unless the transcription is annotated with the correct varient (“A” or “A(2)”), the MAP training can degrade the acoustic models involving that phoneme.

The suggested solution to this problem is to either perform forced alignment or hand-transcribe the data. I haven’t tried methods for force-alignment, yet. Human annotators could use a file included in my version of the ARCTIC prompts: it lists all alternative pronunciations inline in the transcription file. This is slow-going and error-prone, but it may be useful if you’re trying to adapt an acoustic model for personal use?

In any case, the commands to perform the MAP adaptation are below.

cp ../SphinxTrain/bin.i686-pc-linux-gnu/map_adapt .
cp -r Communicator_40.cd_cont_4000/ Communicator_40.cd_cont_4000.adapted
./map_adapt \
    -meanfn Communicator_40.cd_cont_4000/means \
    -varfn Communicator_40.cd_cont_4000/variances \
    -mixwfn Communicator_40.cd_cont_4000/mixture_weights \
    -tmatfn Communicator_40.cd_cont_4000/transition_matrices \
    -accumdir . \
    -mapmeanfn Communicator_40.cd_cont_4000.adapted/means \
    -mapvarfn Communicator_40.cd_cont_4000.adapted/variances \
    -mapmixwfn Communicator_40.cd_cont_4000.adapted/mixture_weights \
    -maptmatfn Communicator_40.cd_cont_4000.adapted/transition_matrices

Done!

And that’s it! All of these commands should terminate within about one second.

Testing

To test whether or not these commands actually did anything, I generated some new/old recognition results.  Test data were the WAV files used for adaptation and I used the 5K NVP 3-gram ARPA language model avaiable from Keith Vertanen’s site.  The acoustic models were the original Communicator model and the MAP adapted model (but I didn’t use the MLLR transform).

This doesn’t tell us anything definite about the performance of the acoustic model in our application, but it shows that the adaptation did do something. Below are the first few recognition results: the first line is using the  original acoustic model (OLD), the second line is using the MAP-adapted acoustic model (NEW), and the third line is the gold-standard transcription (GLD).


OLD: all circuit egypt around philip still successor
NEW: author of the danger trail philip feels it set or a
GLD: author of the danger trail, philip steels et cetera



OLD: not efficiency killer case tom unfair work
NEW: not at this particular case thomas politics with more
GLD: not at this particular case tom apologized whittemore



OLD: further twentieth time at evening into mexican
NEW: for the twentieth time that evening the two men sugar
GLD: for the twentieth time that evening the two men shook hands


Other Resources

A document called “The Hieroglyph” talks a bit more about adaptation and makes a few good points about the number of utterances and the care with which they are transcribed. Some suggestions from that document were incorporated into this post.

Good luck!

For those few souls who share this peeve there is a simple way to replace the applet with a version that always and only shows the desktop.  Reproducing ruizscar’s instructions here:

1. Install "wmctrl" (i.e., sudo apt-get install wmctrl)
2. Add a “Custom App Launcher” to the desktop panel bar with the command "wmctrl -k on"

If you want to completely reproduce the “show desktop” applet, you’ll need to also set the icon.  For the default Ubuntu/Gnome theme (as of 11.04), the icon is located at: "/usr/share/icons/Humanity/places/24/gnome-ccdesktop.svg".  Hopefully that’ll get you in the right neighborhood depending on the theme/panel size you run.

H0: Random hardware failure.

H1: It so happens that the presentation used all black slides with white text. Perhaps the LCD blocking the projector light got too hot, which got the bulb too hot, which destroyed our super-cheap projector bulb?

That’s my clever hypothesis; something to test if you have to give a presentation that you haven’t had time to finish :)

Problem with the First Example

The first example involves facts about Wallace and Grommit.  Here is the program that I load into GNU Prolog 1.3.0.

Listing 1

likes(wallace, cheese).
likes(grommit, cheese).
likes(wendolene, sheep).
friend(X, Y) :- \+(X = Y), likes(X, Z), likes(Y, Z).

This is a straightforward attempt at encoding the knowledge we’d express in English as: “Wallace and Grommit like cheese; Wendolene likes sheep” and “Two different things are friends if they both like at least one of the same thing”.  Evaluation 1 shows the results of querying this knowledge base.

Evaluation 1

| ?- likes(wallace, cheese).
 yes

| ?- friend(wallace, grommit).
 yes

| ?- friend(wallace, wallace).
 no

| ?- likes(wallace, Q).
Q = cheese
 yes

| ?- likes(Q, cheese).
Q = wallace ? a
Q = grommit
 no

| ?- friend(wallace, Q).
 no

The first three queries look reasonable.  The fourth and fifth queries make Prolog search and report correct assignments of atoms to the variable Q. The sixth query attempts this same type of query; however, it fails to find an assignment. This is unexpected, as we know from our second query that Q=grommit is a consistent assignment!

Improved First Example

Listing 2 gives a version of the first example that behaves as expected.  The fix is to move the constraint \+(X = Y) to the end of the rule.

Listing 2

likes(wallace, cheese).
likes(grommit, cheese).
likes(wendolene, sheep).
friend(X, Y) :- likes(X, Z), likes(Y, Z), \+(X = Y).

Evaluation 2

| ?- friend(wallace, Q).
Q = grommit ? ;
 no

\+ is Not Logical Negation

The fact that Listing 2 produces the correct output by reordering the predicates might be unsettling if one’s mental model of a Prolog program is that of a set of logical statements comprehended by a black box theorem prover. However, \+ is not logical negation and, more broadly, it is dangerous to ignore the details of how Prolog goes about searching for solutions.

The predicate \+(M) is implemented as “negation as failure” (NAF). The first thing this predicate does is attempt to prove the goal M. If this can be satisfied, then the next thing the predicate does is to make a cut. Cuts freeze all variable assignments made in a rule, from the beginning up to the point at which the cut appears. Finally, the predicate fails explicitly. All of this machinery effectively causes \+(M) to be false if M is true.

The incorrect behavior in the first program is due to the cut. The M goal in \+(M) contains free variables, and it is easy to find an assignment for those variables such that M is true. The cut prevents any other assignments of these variables to atoms, and therefore \+(M) is always false and the rule can never succeed.

For listing 1, Prolog does something like the following:

1. Goal 1: friend(wallace, Y)
2. Goal 2: \+(wallace = Y)
3. Goal 3: wallace = Y
4. Succeed 3: Y <-- wallace
5. Cut and prevent reassignment of Y
6. Fail 2 with no possibility of success because \+(wallace = (Y = wallace)) is always false
7. Fail 1

By moving the negation predicate to the end of the rule, Prolog will search for variable assignments for the variables in the goal M before the negation predicate appears.  Prolog does something like the following for listing 2:

1. Goal 1: friend(wallace, Y)
2. Goal 2: likes(wallace, Z)
3. Succeed 2: Z <-- cheese
4. Goal 3: likes(Y, cheese)
5. Succeed 3: Y <-- wallace
6. Goal 4: \+(wallace = wallace)
7. Fail 4, with a similar reasoning as above
8. Backtrack to 3 (cuts don’t freeze variables set in other goals)
9. Goal 3: likes(Y, cheese)
10. Succeed 3: Y <-- grommit
11. Goal 4: \+(wallace = grommit)
12. Succeed 4, because wallace = grommit is false
13. Succeed 1, since we've succeeded in all sub-goals

Might’s writeup of the license is great and the license itself is very readable (and funny!).  But in three bullet points: what does the CRAPL (version 0, beta 0) do for you?

• Preemptive social protection: the author can signal that the published code is crap and that he or she knows this so calm down already
  
• Attempt to balance GPL-like sharing of code and data with idiosyncrasies of the publication process
• Does not itself allow commercial nor community use

What might the CRAPL lifecycle look like?

Stage 1:

1. Researcher tackles a problem, sketches a beautiful system architecture diagram on the whiteboard
2. Weeks pass, the stack of coffee filters shrinks, and another xkcd comic appears on the wall
3. “Oh smeg,” says the researcher, “five days until the conference deadline.”
4. Code is hacked, commented in and out, copy-pasted, and… this part never gets old… made to work and produce results
5. Paper and CRAPL’d code is submitted for peer review
6. Peer-reviewers read the paper and have their grad students examine the source code
7. Paper is published.  Huzzah!

Stage N+1:

1. On the other side of the globe, a lone grad student decides to extend the result
2. Student finds the CRAPL’d code– lucky for them, because you can’t fit everything into an 8 page paper
3. Student fixes some bugs and reports them to the original researcher (as-per at least the spirit of CRAPL)
4. Student extends the code, writes a paper, and submits the paper and CRAPL’d code
5. Paper doesn’t make the cut, but the new code remains confidential so the student can try again at his leisure (as-per CRAPL)
6. One month later, the revised paper is accepted, and the student is required to publish the new code, also CRAPL’d (as-per CRAPL)

Might clearly describes the social benefits of the CRAPL.  I’ll pick on some of the issues with the use-control aspects of the license.

The second permission #2 (heh, I will report this bug) is vague.  It requires someone who extends CRAPL’d code to make a “good-faith effort” to contact the original author.  As long as the license is tailored to our current academic model, why not define a minimum “good faith effort”?  I propose that sending an email to the authors’ email addresses (specified in the CRAPL license file) with attached code modifications OR bugfixes relevant to the original code?  (Luca Ferrari pointed out this issue)

The last permission, concerning the release of any input data used to generate published results, is contentious.  Acceptable or not, there are a lot of research results generated from data that cannot be released to the public.  Company-confidential data may be used in a publication from Google or Microsoft.  Data from experimental subjects is often protected by confidentiality requirements, as in some medical and psychological studies.  Data may only be available for a hefty fee from a third-party or may require several hard drives and hours of a researcher’s time.  I would modify the license to allow the original author to decide whether input data must be released and how, with a default of no restrictions.  Perhaps a later version of the CRAPL should fight the open data battle.

Where does the CRAPL fit into my licensing philosophy?  As a first approximation, I feel that the GPL is appropriate for end-user software, the LGPL or BSD/Apache is appropriate for libraries or “good” code, and the CRAPL is appropriate for means-to-an-end research code.  Apart from social signaling, releasing under the CRAPL allows you to release code for scientific reasons while still holding the door open for later commercialization or alternative licensing.  For the benefit of science, it encourages peer-review of code, communication of bugs and issues, and a kind of parallel continuity between code and published papers as scientific ideas wend their way through the literature.  While it may need a lot of work to be a legally bulletproof license, it is probably worthwhile to use as-is because it (1) doesn’t seem to give up the author’s copyright and (2) the scientific community has a decent sense of right and wrong concerning the correct use of other scientists’ materials.