I hope you enjoy the ride.

Recently I’ve become fascinated with the concept of functional programming. For several years, I’ve had friends jump from language to language, but they all seem to settle on the functional side of the fence. “Why?” was the inevitable conundrum. For the longest time I couldn’t understand what it had to offer that you couldn’t do in other languages. Like most programming phenomena, it was an epiphanic moment that changed the way I looked at programming for the better forever.

Code is Data; Data is Code

Ok, omgwthbbq does this mean? How is code parseable data? How is data trustable code? For this, I had to rethink my stance on what makes a program an executable, not where the program comes from; it’s a cart-before-the-horse thing. So what makes a program? A program is executed lines of human-readable text compiled or interpreted but just the same converted into machine code before the processor reads the 1′s and 0′s from one stream and pushes a different set of 1′s and 0′s into another stream. Who cares how those lines got there. Could be from hand-entry, or it could be from a variable.
Epiphany the First: Who cares where we get code as long as it’s the right code we need?
PHP has this: variable function names, eval(), call_user_func(). After you start coding using these patterns, it becomes nearly impossible to think otherwise. All of a sudden, “Gee, it would be so much easier if we could just tell functionY about functionX without having to teach classB about classA.” We stop thinking in terms of step-by-grudging-step and into segmented solutions to problems. When we can just pass a function into functionY of classB, this problem disappears. classB doesn’t have to give one darn about classA, just that when it needs to, it can use functionX and the world will keep on spinning.
Epiphany the Second: What data can I trust?
Well, you can trust mine, silly! After all, I wrote it. Ah, so data doesn’t have to come from the user, it’s just a way of saying the A’s and underscores I put into the program can be used to reference other parts of the program without explicitly teaching them about each other. Data can come from anywhere, even code; and code can be executed from anything (with the right compiler/interpreter) including data.

Hopefully, this will spawn my first Git repository. Stay tuned for the linky!

[Edit July 7] Instead of a full-fledged repo, I just threw the PHP code up on gist.github.

I hope this next year will afford me more time to write, as I’ve enjoyed all the comments I’ve received from you readers. I have plans on documenting and devoting a page on this blog to two new Open Source projects I’ve written since starting this site; accepting suggestions, comments, and hopefully remarks that they were useful to you.

Thanks for reading.

I jumped ship to Eclipse for Java development several years ago. It was Free, independent of Sun, and had a plugin architecture. It wasn’t until some errant day that I fortuitously pressed Ctrl+Shift+c to toggle a line comment. I was floored! Oh, rational and easy keyboard shortcuts, where had you been all my life?! I remember, tied up in some “Ctrl+Alt+x-tcomment” command. No longer!

Then, after I began really customizing Eclipse, right around Ganymede, I started tweaking the keybindings to just-suit my likings. I bound Ctrl+Alt+s to Save All, Ctrl+Alt+q to Close All, and Ctrl+Alt+r to Run. It was glorious. My high-school typing teacher told us that two hands on the keyboard will always be faster than a mouse. I’d have to amend that statement and say that it certainly is, for particular tasks. The key is to bind the right tasks to easy-access shortcuts, and you’ll never be beaten in a speed-test by a mouse-driven GUI.

Recently, I’ve again changed loyalties and moved to Netbeans. (Aside: Eclipse was wonderful, and I still have a soft spot in my heart for it, but the explosive memory usage and frequent hangings made it unusable.) It was a tough switch, though. I had tried several years before, and ran into what I considered a major usability problem: lack of multi-key bindings. By the time I was ready to switch, I was almost ready for Emacs. The fact that I could nest actions into multi-key-multi-mask shortcuts was downright awesome! By then, I’d had intimate exposure to SVN and couldn’t live without my Ctrl+t-Ctrl+c check-in binding; (“t” for “team”, “c” for “check-in”). It wasn’t until recently that I gave it another shot and am so thankful for the effort. I’ve discovered an entirely new realm of happiness for an IDE. Assigning and navigating bookmarks takes less than ten seconds and jumping to the declaration of a function to see the actual code, then right back to where you were is easy as Ctrl+d-Alt+Left!

Custom keybindings will save your life, or at least make you twice as productive. Learn them, use them, enjoy them.

I suppose more than anything, I just needed to recharge the batteries, as it were. Being a digerati only allows for so much creative thought to be put into extracurricular activities before you owe it back to what you’re being paid to do. And, while I absolutely love putting my opinion and my works out to the public, (expect to see at least one post about GitHub and it’s glory soon), I just realized I didn’t have the content to keep up with this (or any other) blog. So rather than pollute what I strive to make otherwise a substantial addition to your Google Reader feeds, I’ve left this smolder.

But having a moment now, I’m finally in a rejuvenating mood that I believe is worth sharing with all my readers. If you’re mildly interested, I’ve had many starts to articles on various topics which I hope to finish: CSS syntax, Django bugs, and an expansive description of an open source project I hope to put on GitHub very soon regarding the new CANVAS HTML element.

In short, I’m back to writing in the techblogosphere, and I’m quite happy about it.

Last week, Facebook launched vanity URLs, like your MySpace usernames only with “facebook.com/” in front of them and about two years late. Thank God! Now I don’t have to memorize my 12-digit, numeric user ID and those of my friends. Death to friend codes! (You hear that, Nintendo?)

As someone older than twelve, (which, by the way, twelve year-olds should probably not be allowed to have FB accounts – there’s some nasty stuff on there), I’m not particularly fond of keeping my “handle” around for the rest of my life. Being creative is fun, but eventually all dads need to lose the bell-bottom jeans and overly-long mustaches. Now’s the time of boot-cut and goatees, get with the program!

Some FB users didn’t get the memo, however; and their loyalties are abundantly – and permanently – clear. There are Halo fans, ([1], [2]), Star Wars junkies, ([1]), and g33k5 in general, ([1]), and assholes, ([1]), that abound.

I’m all for indulgences, but even I don’t think I could profess my unwavering allegiance to the Horde or play such a practical joke on a friend like that. Way to go, fellas and lady, you’ve successfully wrought detrimental opinion to the entire community; though you’ve sure made a great many of us laugh our asses off as well!

(Inspired by TechCrunch.)

IE8 continues this misguided charge with Web Slices, a particular element of a page which the browser can selectively update asynchronous to the rest of your behavior. In lamens terms, consider it to be RSS on crack. The idea is kind of cool and interesting as a developer: Provide desktop and web apps a URI to a manageable piece of information that can be parsed relatively frequently for updates.

My issue is two fold: (1) the URI Microsoft defines is nonstandard and trivial; and (2), why should we learn another set of proprietary syntax for what should be defined elsewhere in the page or headers?

As for the URI, XPath is a much stronger and cleaner way to identify what is subscribable. Why should I be limited to just one element at a time? XPath would allot me several subscriptions all at once. A URI like http://blog.adventdigerati.com//*[@class="story"]:first would give you my the snippet to my latest blog post, and omitting :first would give you all the posts on the front page. Why is that so hard?

Secondly, most of Slices’ API is defined using bastardized (X)HTML elements and attributes. Even I learned that text content should not be used to define semantic meaning in a document; it’s a corruption of XML standard, one of the best directions in web standardization so far. How hard would it be to include a custom <meta> tag in the <head>? Namespacing a custom tag would be sufficient, and you could even achieve the same effects MS wants via these methods. <meta name="ms-slice-title" content="/absolute/path/from/slice/root/to/title/tag"/> would give a consistent way to retrieve the titles for each slice with one line of code! Or, if need be that the slices be drastically different, <meta name="ms-slice-ttl" content="//*[@class='entry-content']"/> would parse slower but achieve the same goals, and be standards-compliant.

In all, everything Microsoft wanted to get out of their new Web Slices feature could already be done using existing tools; let’s not clutter what could be an awesome new tool for developers with sub-par requisites that somehow shoehorn their way into standards by just being left to fester.

What I didn’t know, is that this could get us into a lot of trouble without even expecting it. The problem occurs whenever you try to obtain a reference to an element in a PHP array. Case in point:

$a=Array("one"=>1, "two"=>2,"three"=>null);
$b = $a["four"];
$c =& $a["five"];

What do we get if we print the value of $a variables? $a is now

$a = Array(
  ["a"] => 1,
  ["b"] => 2,
  ["d"] => null,
  ["c"] => &null
)

WHAT?! What happened to $b? What in the world is a pointer to null? PHP actually created the “c” key within my Array, just by referencing it in a read context. Lesson learned: always use isset($a["key"]) before attempting to draw from an Array by reference!

Along the road to enlightenment, I’ve had some superlative teachers, professors, and friends instruct me on the best ways they knew to implement everything from Levenshtein Distance to Diffie-Helman compression, from polygon intersection to Relational Division. These lessons weren’t always apparent, and hardly ever enjoyable, but the knowledge and satisfactoin at the end of the project often put me years ahead of self-study.

Several times, I’ve been asked questions to which I’ve had absolutely no idea as to the solution. Yet, right then and there, an answer was demanded of me. It’s difficult and embarrassing, but situations like these are more about the reasoning than an off-the-cuff answer. This is an important concept, since it is a large step on the road to Doing Big Things.

Such occurrences were relatively commonplace, and for a long time I couldn’t figure out why someone looking to help me was asking a question that I either obviously had no business answering, or that was completely over my head. Then, just a few days ago, I stumbled onto the concept of zen. Zen, for want of a clearer definition, is the internal feeling and state of mind which is, in rudimentary forms, omniscience about a subject. It is the absence of bounds or form of knowledge in an area of concentration or meditation.

Zen and the art of programming was an interesting thought experiment, and until then I had no idea zen was being taught to me the entire time.

A mondo is a component of zen scripture where the roshi (`roh-shee) [teacher] asks the student a question, demanding an immediate answer. Since this question is often complex or multi-part, the process of developing the answer is more critical than the answer itself, akin to the Biblical scripture of teaching a man to fish. Had the pupil regurgitated some decade-old algorithm learned in Intro to VisualBasic doesn’t further the understanding of the problem at hand. Just because you may have learned bubble sort first doesn’t mean it’s the best choice for your production code base. A mondo would solve whether insertion sort would suffice instead of spending two days of company time implementing heap sort; and, more than that, it should help you realize the patterns in the future to prevent the same questions from needing attention again.

This insight, the ability to anticipate or at least keep pace with the business’ needs, is one of the most efficient ways to show off one’s skill in a profession. Especially now, when employers need to “cut off the fat” out of their budgets and reign in on ambitious funding of pipe-dream projects to stay competitive.

And there’s no reason you shouldn’t want to continue to learn. If nothing else – and trust me, there’s plenty else – you will bring those skills back to the workplace every day, inspiring those around you and impressing your superiors. That’s not even counting the personal satisfaction of reasoning through an enigma and coming out the upper side with a better solution or clearer understanding of the problem.

I am going to argue against myself here. I realize that in a prior post I praised PHP dereferencing, longing for the direct pointer manipulation of Perl, by using $value=true; $name='value'; ${$name}==true. However, for the next developer, he or she must understand prior to inheriting the code, how PHP handles inline eval() statements.

In situations where the use of these is unavoidable – usually in dynamically-created variables, LISP anyone? – a detailed comment is assuredly in order. Even if it is simple, an example, the next programmer to stumble across your code should be able to reasonably expect an outcome from the procedure.

In JavaScript I’ve been writing lately, I’ve become very cautious about the nature of functions and closures. Frequently, I’ve adopted the practice of namespacing everything I write. Because of that, grouping functions down to the program area can be tedious. No programmer wants to see com.acme.financial.payment.forms.construct(). With JavaScript, we can fake a with() statement. var pay_form = com.acme.financial.payment.forms; additionally com.acme.financial[params['object_type']].forms[action](params_hash) can save a lot of code later in the process.

As an engineer, we should always be looking for ways to perfect our trade. Often this means coding cleanly, and using conventions. Sometimes this means using quirks to their biggest advantage: shrinking the codebase. Remember, one bug for every ten lines.