What is your "nightstand" code?
I only read the first and the third essay, but I must say, wow!
The third essay, for instance, takes a simple 12 line implementation of quicksort in C (which is already quite beautiful), and through a series of well explained transformations, arrives at a four line proof (as in, it's C code that is equivalent to the recurrence relation, and eventually the summation, we all solved in our CS classes) of the average case complexity (~1.4nlgn comparisons) of the quicksort he started with.
That is what I would consider "nightstand" code, or at least a nightstand essay about code. It was actually entertaining, to the point that you don't realize you are solving a recurrence relation in C form until the end, when the parallel becomes obvious.
I only had a chance to skim the other topics, but I'm actually considering buying it, because it really was a blast to read.
Definitely not _the_ most beautiful code I've written, but I still enjoy this little function for some reason. It's just pretty to me.
function addparams(query) {
return query.replace(/(&?)([^&=]+)=([^&]*)/g, function(m, amper, key, id) {
var val = document.getElementById(id).value;
return val.length > 0 ? amper + key + "=" + escape(val) : '';
});
}
<input type="text" id="first" value="defaultfirst"/>
<input type="text" id="last" value="defaultlast"/>
$.ajax({
url: "/path/to/page",
data: addparams("fn=first&ln=last")
});
/path/to/page?fn=defaultfirst&ln=defaultlast
if (c < 0x80) *(s++) = c; // US-ASCII subset
else { // multi-byte UTF-8 sequence
for (b = 0, d = c; d; d /= 2) b++; // number of bits in c
b = (b - 2) / 5; // number of bytes in payload
*(s++) = (0xFF << (7 - b)) | (c >> (6 * b)); // head
while (b) *(s++) = 0x80 | ((c >> (6 * --b)) & 0x3F); // payload
}(Not because it's perfect and beautiful, but just because I wrote it and understand it.)
Report writers, data base update objects, data formatting routines, form processors, string & array handlers, special logic algorithms, and especially, code generators.
The more I read these, the better I know them.
The better I know them, the easier to improve and extend them.
The more I extend them, the better my software gets and the less of it I have to write to get anything done. Leverage.
I literally have a folder of all this stuff on my nightstand or in my backpack all the time.
- Some bits of On Lisp
- Haskell's SYB and Parsec libraries
- MINIX (2; have yet to play with 3)
http://www.amazon.com/Programming-Pearls-2nd-ACM-Press/dp/02...
* Doesn't repeat itself. This includes languages which involve marking out blocks of code once for the interpreter and the second time for humans.
* Is short, because it doesn't reinvent common modules, and modularizes out general logic.
* Uses descriptive names, including using dictionary keys rather than vague list element numbers. A good test is if you can show the code to someone who doesn't work in computing and have them understand it. ZS had a talk on this where he showed lawyers SOx code and received feedback on the rules, changes to the order, etc.
* Uses tree structures for tree structured data (eg, etrees and xpath) rather than treating such data as strings and using RegExs.
* Has docstrings.
http://en.wikipedia.org/wiki/Shakespeare_(programming_langua...
Not because it's direct computer code, but because when I'm reading it past code i've written starts swirling in my head. Sort of one of those "ahhh fantastic" moments.
/ yes it did make me laugh when I read it in Atari St user */
http://en.wikipedia.org/wiki/Shakespeare_(programming_langua...