Several years ago, I had to get a physical for a job I had taken, and as a part of that physical, I had to be weighed. This was about a year after I got out of college, where I had been large-shouldered but fairly trim from the shoulders down. My weight throughout college was about 185. I knew I had put on some weight in the intervening year, but I wasn’t prepared, when I went to get my physical, to learn that I had blown up to 220. I was bigger, sure, but I didn’t look 220. I should have known then that I was out of the running for a career as a carnie weight-guesser.

Lennie has, by several accounts, gotten a good bit bigger in the last few weeks. I haven’t really noticed it because I see and hold her every day. Incidentally, I’ve long thought that the kids you grow up with always look exactly the same, even when they look markedly different. I wonder if anybody else has noticed this. So when Mleeka made an appointment to get a weird mark on Lennie checked out, I didn’t figure she’d be that much heavier than she was at the last appointment, a couple of weeks ago, at which she weighed 9 pounds, 1.5 ounces. Maybe, just maybe, she’s up to almost ten pounds, I thought.

Hur-ray, hur-ray, step right up, for two bits I’ll guess your weight, and if I’m wrong, you can treat your little lady to this big purple stuffed gorilla.

As it turns out, she’s a whopping 10 pounds, 6.5 ounces, and that’s with a virtually empty tummy (when she was losing weight early on I always had to resist the urge to really load her up with a good meal just before her weigh-ins). And so, alas, my dreams of one day becoming a carnie have been obliterated. I do take some consolation in the fact that Lennie’s healthy and well-fed, as evidenced in a picture of her sacked out after a feeding and the subsequent digestion-promoting walk. (I personally have my doubts as to whether or not Mleeka’s walking the baby around has any real digestive benefits for the baby.)

Note that her belly is substantially larger than her sizeable head. It isn’t altogether improbable that, having so large a belly and so large a head, Lennie might one day find herself on the midway, taking cannon balls to the gut or barking at marks to step right up and throw the ping-pong ball in the fishbowl or the softball in the milk can. One could even hope that she could aspire to that grandest of carnie professions, the ride operator. I drove a roller coaster one summer during my youth, though not at a roving carnival as would be ideal, and we all know how fathers love to have their children follow in their footsteps. Ah, the grand life of a real live travelling carnie (my position was at a static amusement park), ogling the hotties walking by in their revealing clothing, standing around acting carefree and nonchalant, limbs dangling and cigarette ember throbbing between pulls on the lever that sends the ride du jour whirling and rattling in its particular fashion, shirtless and shiftless and probably a little bit drunk.

Here’s Lennie mugging for her carnie portrait. We didn’t get a picture of her with the cigarette, but note carefully that her hand is en route to the heavy metal devil’s head gesture and that she’s opted for the topless look (part of why I think she’s destined to be a ride operator, as the game operators keep their shirts on). And don’t miss her biceps. She’s made for the midway, I tell you. Made for it.

I’ve watched a (very) little bit of the Democratic Convention this week and have noticed a couple of anonymous literary references. By anonymous, I mean that the quotes were given without citation.

Ted Kennedy made reference to a poem his brothers loved and finished out the reference by saying something to the effect of “as the poet said” and reciting the closing line of Tennyson’s “Ulysses”: “To strive, to seek, to find, and not to yield.” What struck me about it was the flourish of saying “as the poet said,” which is sort of an open-armed gesture to the audience, as if to say “here I am, a man saying things intellectual, and I know that you surely know which poet wrote that line, so there’s no need for me to be explicit about it.” This seems a pretty crafty maneuver because it either stands to make audience members feel included and validated as people it’s taken for granted have a sound cultural and literary education or to intimidate audience members into a sort of reverence for the speaker, who, knowing abstruse references like this, must surely be smart enough to be worth listening to.

The other literary reference I noticed was John Kerry’s anonymous reference to a great author (Thomas Wolfe, one of North Carolina’s literary sons, much as Runningmate Edwards is one of North Carolina’s political sons — will flattery win the state for Kerry?) who wrote that “you can’t go home again.” The relevance, of course, is that the convention is in Boston, which Kerry calls home, and he’s glad to be home again. Relevant or not, the reference still stood out to me as a pretty shrewd tactic for positioning Kerry as an intellectual and instilling in undiscerning audience members the feelings either that “this guy respects me enough to think I’ll get this reference, and I like that, so I like him” or that “this guy must be pretty smart because he knows random literary references, so I can trust him to make informed decisions on my behalf.”

I don’t imagine we’ll hear quite the same things from the Bush camp, which I suspect will fall back on the mantra “America is safer now.” Recall that by definition, a mantra is meaningless and is designed to empty the mind.

At the last election, the focus for many Democrats (myself included) seemed to be that Bush was a moron. For Republicans, it was important to tag Gore as a hanger-on to the immoral Clinton administration and as a stodgy, elitist intellectual. To my knowledge, Kerry doesn’t have any skeletons or ties with people or organizations branded immoral. I’m not sure Bush can say the same, though those who favor him would disagree. At any rate, I’m wondering if intellectualism might make another appearance in this election, but as a desireable rather than an untrusted trait.

I’ve been wanting to try WordPress as my blog software. I had been using the b2evolution system, which at some point was merged into WordPress. My new interface certainly has some familiar components, but it’s much more full-featured. In fact, the only thing that seems to be missing is built-in stats, and plugins can be downloaded to handle that. I didn’t try to port my skin over, and to be honest, I was a little tired of it anyway. Might as well have something simple and more legible that doesn’t do weird breaky things in some versions of Mozilla. Maybe I’ll add a snazzier skin at some point, but for now, I’ll just stick with the current clean look.

Reconsidering Standard Web UI
A year or so ago, I took it upon myself to write a PHP class that would make form-building simple. Call the constructor with a few options (such as the URL, the method, and whether or not to include a js validation script) and then begin adding your elements, passing various bits of data such as the row and column within a table, the name, type, value(s), CSS class, validation rule, etc. Then call the execute method and you’ve got a nice form generated from PHP code without having the HTML tags written in the code itself and rendering it unreadable. Pretty nifty.

Shortly after writing the first version of this code, I discovered CSS Zen Garden, which showed just how versatile CSS can be. Given the same HTML source code and allowed to alter only the CSS definitions, dozens of designers have created vastly different site templates of sometimes staggeringly good quality. Well if they could do that, I thought, then surely I could use CSS to build a sharp looking Web application interface that looks less like a Web form and more like a desktop application. My particular challenge was to roughly emulate a Windows application my company uses to manage projects and resources. It’s a tabbed application, and each tab panel has subsections with nice sunken borders and blue header labels. It’s not the sort of thing you’d typically try to build using HTML, but with my newfound reverence for CSS as an architectural tool rather than simply as a way of defining font and color attributes, I decided to try the typically untried.

With a few changes to my form class, I was able to pass div names and to set titles for subsections within a given page. The class generated divs within divs (a title and a content div within a parent div) for each element group defined for a given form. The CSS included for a given page contained definitions for each of these parent divs as well as more generic definitions for the look of the title div (blue background, bold white font, some padding, offset from the parent by X pixels in one direction and Y in the other) and the content div (gray background, gray/white borders to give the appearance of depth, some padding, and an offset) within the named parent divs. With really minimal effort, I built an application front-end that resembles very closely the appearance of a thick desktop application. Yay for CSS.

But even that has limitations. First off, although it’s good to separate the content from the logic from the styles, it’s sometimes a pain to keep everything in sync. Add a field to a subform within a page and you’ve got to go to your CSS to change the vertical position of any subforms below the one you just changed. And to do that, you have to go into the display code to determine the name of the subforms in question so that you can change the appropriate style defintions. And then you have to test it in all the browsers you anticipate will be using the application. What’s more (and this is a minor consideration, but it is a consideration), if a Mac user saw my application, he’d find it odd and perhaps a little off-putting that it looked like a Windows application. And finally, the main barrier to using Web applications efficiently is the time spent going back and forth to/from the HTTP server. You request a page and wait for it to render in your browser. If the page has a data grid representing 100 rows of data with 20 columns per row and all sorts of validation routines, select boxes, etc., for many of the columns, it can take a few seconds for the page to render. When it finally renders, you make your changes and submit the form. It goes out, talks to the business logic part of the application, and returns. My applications most often return to the page just submitted, with the values changed and a status message prominently displayed. Which means that the 100 rows of 20 columns have to be reloaded. Which can get a little annoying for the user in spite of how cool an accomplishment the application is from a technical standpoint.

The Plot (and Application) Thickens
So if Web applications are such a pain and are especially prone to scalability and performance issues, why use them? The application I originally modified my form class to emulate was a thick desktop application, after all; if I was wanting to get away from that particular application, why not just code a better thick desktop application from scratch?

In short, I didn’t do that because it’s just so darned hard. While I’m sort of proud to be able to answer the “so what do you do” question with “I’m a developer,” I’ve always drawn a line between the kind of development I do and the kind “real” programmers do. I’m a glorified script kiddie, hacking together interpreted code and using simple markup languages to perform some really pretty basic tasks. There’s a big difference between collecting form data for input into a database and engineering complicated applications for manipulating satellites, say, or for editing images.

To my mind, the substantial difference can be boiled down to having (vs. not having) the ability and resources to write compiled user interface code for the front end that hooks into compiled business logic code on the back end. Any number of times, I’ve fired up an IDE for building user interfaces and have dumped some widgets onto a layout grid to make a neat looking application. But then I’m confronted with making the widgets actually do something, which means facing the blank screen of a C or C++ editor and figuring out what to write. Which is a lot different (for me) from confronting a blank screen when writing a Web application and knowing that if I just use the elements contained in the $_POST array, I can work magic with the data submitted by form to the page I’m editing. It’s not that I’m incapable of figuring out how to write the C or C++ or python or java code, incidentally. I just always get to that point and remember that I haven’t learned yet how to connect the UI to the back end. And I move on to the next thing because I don’t have the time or the resources or, in some cases, the gumption to figure out the rough equivalent in the given language of using the $_POST array in PHP or the beefy CGI.pm in perl.

For all their benefits (most notably efficiency and a reduced likelihood of hackability), thick applications don’t come without their warts. As noted above, for example, connecting the UI to the back end strikes me as a bit more abstract. And I find rapid application development in strictly-typed languages to be darned near impossible, not to mention that deployment and maintenance of thick applications can be a bear. Need to change the spelling of a hard-coded label? Edit, recompile, test, and install on necessary desktop systems rather than just changing a text file on the Web server. Cross-platform functionality and easy installation across platforms can also be painful for thick applications.

Web < Rich < Thick, or Meeting Somewhere in the Middle
If Web applications don’t quite cut it for the user but thick applications are overkill for the wannabe programmer, what’s to be done? Are we script monkeys resigned to delivering sub-par applications to our users, and are uber-programmers made to kill flies with cannons by writing thousands of lines of code to build simple applications? Well, no.

It turns out that there’s a handy framework called XUL (pronounced Zool and short for XML User Interface Language) that taps into OS-native widgets and can hook into business logic in any number of ways. The foundation of a growing number of “rich” (somewhere between thick and Web) applications, XUL is XML-based. That is, you define the interface for an application by writing an XML document that the underlying engine uses to communicate with the OS to generate the appropriate widgets. Which means that an XUL application looks like a Mac program on a Mac, a Linux program on Linux, and a Windows program on Windows. And which means that in order to change a widget, you need not edit and recompile/test/redistribute an application, but need only to tweak the XML document defining the UI. XUL documents can be installed locally or distributed over the Web as XML documents. And they can hook into the codebase of your choice (a javascript XML-RPC client that interfaces with a PHP XML-RPC server, for example) that takes care of the business logic. There’s only one catch: It requires that the Gecko engine (most frequently found as a part of Mozilla) be installed. As I happen to be a Mozilla user to begin with, this doesn’t present me with a major problem. And the Mozilla issue isn’t really a hurdle anyway. The latest versions of Mozilla Firefox are very small to begin with, and XUL applications can be run as chrome packages rather than through the browser itself, so if you’re not willing to use Mozilla as a browser, you need only install it as a substrate to support your XUL applications, which when run as chrome packages bear no mark of or resemblance whatsoever to Mozilla.

The Tip of the Iceberg
But all XUL does is to define the user interface. Don’t get me wrong — this is no trivial accomplishment: We’ve gone from having to build and name and size and position and otherwise tweak (wrestle with) form elements in a complicated IDE to writing a brief structural document outlining what elements should appear within an application and roughly where they should go (XUL’s pretty smart about stretching and moving things to fit nicely, though you can provide hints and even add CSS definitions if you want more granular control over elements). For example, a sample application I put together contains three tabs, configured as follows:

• Search Tab. Contains a search box and button to trigger the search.
• General Tab. Contains about a dozen fields to hold contact information for a given person.
• Extra Tab. A blank tab that other fields could be added to and that I originally built to help me test my database functionality (about which more in a moment).

The tidy and utterly readable code to produce this GUI runs 135 lines including white space and declarations of scripts used to perform the business logic of the application. If I want to change a field label, I make a change to the file, reload it in my browser (or using the chrome option as demonstrated above) and I see the change immediately and without recompiling a thing. If I happen to deliver the XUL file over the Web, once a given user redownloads the application (which, note, is very concise and, even with the download, takes less time to load than your standard thick application), he sees the change immediately. In other words, reworking and redistributing parts of the code need not be a nightmare.

The Rest of the Iceberg
In order to make your application do anything besides display a bunch of widgets (the barrier I’ve always hit when working in fancy IDEs designed for putting together complex GUI applications), you have to write some business logic code. This is where XUL applications showcase their appeal to the wannabe programmer. Don’t know C or java? No problem. Write your business logic in javascript and PHP. I know some C and java but happen to be much more familiar with javascript and PHP. I also happened to find an astonishingly helpful tutorial over at MozTips that kept me from having to figure out on my own how to build a javascript XML-RPC client and make it talk to an XML-RPC server. That tutorial makes use of the JavaScript o’lait library, in which you’ll find some javascript that’ll blow out of the water your current appreciation of what javascript’s good for (you can do a helluva lot more with it than image rollovers). I won’t go into a great many details about the implementation of my particular application because every application is going to be different, but I will provide a breakdown of how the application communicates with the server and gets data back.

First, you do something in the application. In my case, I enter a string into a search box and hit a button. The button triggers a command that lies in one of the included javascripts. That command in turn taps into the DOM to extract the search string. It then connects to the XML-RPC server (a PHP script), sending the search string. The XML-RPC server listens for a given set of commands and throws an error if a bad command is passed or if the parameters are no good. The server maps public called commands (what the javascript sends) to internal PHP function names, and if a valid command is called, the internal function is called. The internal function then uses PEAR’s XML-RPC goodies to decode the XML it receives, to perform some operations on the resulting data (in this case a simple query of the mysql database), to reencode the result as XML, and to return the XML as an XML Response object. Meanwhile, the javascript XML-RPC client function called by the button command has been sitting around waiting for the response. When it gets a response, it processes the value, popping up a “No match found” alert if it gets a false return and focusing on the General tab and setting fields to data values if an array is returned.

The result is seamless communication between what appears to be a thick desktop application and some data source. There’s no page reload, no flicker or long pause as form elements are rebuilt. The application itself is running locally, so it’s rocket fast. And because I’ve got a speedy apache/mysql server, the data retrieval takes no time at all. Furthermore, I can eliminate the need for a submit button (one of the biggest complaints among my users, who use a blend of Web and thick applications) by executing update commands (for example) on tab focus or exit.

XUL applications provide the best of both worlds, a native, platform-independent client with the flexibility to hook into local or remote business logic of varying sorts. I’ve chosen to use XML-RPC as opposed to hooking into custom C code that does database connections natively and performs more like one of the applications I’ve had a mental block against writing in a complicated IDE. The nice thing about the XUL framework is that you can write your own C libraries to manage database connectivity natively if you want to (at a substantial overhead savings, no doubt), but you can also tap into existing code or write XML-RPC servers that you can access from several applications (at a code redundancy savings) or do pretty much anything you want to. If you’re intrigued, check out XUL Planet for a complete XUL reference, or download Mozilla Firefox and Thunderbird (Mozilla’s standalone mail client). Both of these full-featured applications are written in XUL. They’re trim and fast and cross-platform-friendly and serve as the best examples to date of what XUL can do.

With a little luck in the form of management buy-in, this wannabe programmer will have another fine example by the end of the year.

Steven Frank brings spam to life by drawing little pictures based on the subject lines. In related news, spam poetry is becoming a bit of a fad. Check out a few examples at Finite Monkeys.

I haven’t yet had a chance to expose Lennie to Dr. Strangelove, but she could sure use the exposure. That kid leaks every which way. She’s like a blooper reel. She’s a veritable fountain of things yellow, brown, white, and clearish. In short, she has no appreciation for the worth of her precious bodily fluids, and she doles them out freely.

For example, during her first week home, I found her diaper to be full of pee and went to change it. My methodology is to lay her down, hike up whatever outfit she’s wearing, unfold and place a new diaper under her, undo the old one, make whatever ablutions are necessary, tape the new diaper into place, reinstate the clothing, and exit the changing area. I had progressed through step five (making ablutions) and was about to secure the new diaper when she grunted and raspberried the new diaper dirty. A waste of fluids and a diaper! Having expelled such a volume of bodily fluid, I thought to myself, she must surely be finished and very nearly spent of all her energy. So I resumed the changing process at step three (unfolding and placing of a new diaper under the old one) and continued to step four only to discover that she was unspent indeed and that she was being yet more generous with her precious bodily fluids. Another diaper wasted. This time, I learned, waiting several minutes while encouraging grunts and squeezes and other fluid-expulsion facilitating behaviors before picking back up at step three again.

Lennie also happens to be fond of sporting the cheese-neck look. It’s rather like a turtle-neck, but dribbled and burbled down her cheeks and chins to form a fashionable white collar (and after Easter, at that!). She’s been especially bad about this the last couple of days.

But that’s not all she does with her milk. For example, I sometimes call her Daddy’s Little Ruminant as she stares at me, blinking slowly and chewing the cud of a freshly swallowed and partially-regurgitated repast. And she’s been known to blow a bubble or two.

Last night, she performed perhaps her best bodily fluid trick. I sat in my overstuffed chair, feet propped up on the coffee table, holding her upright on my chest as I often do. As often as I do this, I angle her up and crane my head down and plant a big juicy kiss (or two or fifteen) on her little rosebud mouth. She usually makes an ugly face when I do this, but I simply can’t resist. Having already given her a post-dinner horsey-ride jostling last night, I cooed and crooned and talked at her, eventually and predictably bending down to plant the customary smooch on her pursed little lips. Whereupon, with perfect timing, she delivered a sip — no, it was more of a gulp — of regurgitated milk straight into the open spout of my mouth.

I’m not sure I’ve ever laughed harder at anything she’s done, and I find her most amusing on a regular basis. Such timing my little girl has! And she delivered her little practical joke deadpan, which is very hard to do. I guffawed and congratulated her and took a careless swipe at my mouth to clear the splash away from my face (Mleeka came along a minute later and wiped some drops out of my beard) and didn’t care one jot that I had been spectacularly and, by some accounts, no doubt, disgustingly slimed.

Which goes to show that once you become a parent, you begin to develop immunities to things formerly considered gross. I’m not surprised by this, incidentally. I knew it would happen. It’s just funny to see it happen, and to happen to such an extreme. I had already established an immunity to poop, happy as a clam to jam my nose into the leg of a diaper to ascertain the flavor, if you will, of the gift contained therein. And getting a smear of meconium on my hand? No big deal. But the ingestion of spitup had always seemed so much more germy, somehow less washable and forgettable. Turns out it’s not forgettable, but not in a bad way. Lennie’s knee-slapping delivery of this bodily fluid was precious indeed. How could I begrudge her such a waste?

New and upcoming dads, have no fear: I have invented two maneuvers that will make holding your child fun and easy. Perhaps I’m overstating the case when I suggest that I invented the maneuvers, as they have assuredly been used for centuries, if not millennia. But I describe them here for the benefit of others nevertheless. I do believe the names for the maneuvers are original.

Some background information will be useful, primarily to upcoming dads, as new dads will have discovered some of this for themselves. First, babies are not footballs (though there is a nursing position called the football hold and I have discovered a yet-unnamed transitional maneuver that’s a vaguely footballish hold — more on that, perhaps, when the muse of baby-holding inspires me to invent some new names). They’re more like little ten-pound sacks of potatoes with occasionally wildly-gesticulating limbs. That is, they’re at once rigid and limp, still and kinetic, distinctly and indistinctly shaped. This makes holding them a challenge sometimes. Second, babies do not cotton to being dangled like tennis racquets by one doughy limb; they require a smidgin more support. Third, when you’re trying to hold a rigid/limp, still/kinetic, (in/)distinctly shaped baby, you’re hard pressed to get much of anything else done unless it can be done with feet or lips. (Happily, this means you can kiss the baby and walk the baby, both of which behaviors delight the baby.) And fourth, babies like to get lots of attention, including lots of silly talking-to. I mention this last bit of background information for two reasons. First, it turns out that even the most reserved of men are prone to launch into a babble of the inane and the absurd when talking to their children. I have so far covered various schools of thought with my child, ranging from theoretical physics to philosophy to grammar to techniques for teaching difficult concepts like sameness and difference to randomly silly things. I have also sung made-up-on-the-spot songs about bodily functions and sitting in my lap and having fat little cheeks. And I’ve managed to suggest that my child is the first Black Panther to be seen wearing a pink layette. Second, it was during one of these one-sided conversations that I conceived of the names for the maneuvers. So the baby, being the cause of my stream-of-consciousness rambling, gets at least partial credit for the origination of the names.

Which names happen to be, as the title suggests, “The Chicken Wing” and “The Modified Chicken Wing.” This last is also known as “The Half Nelson.”

The Chicken Wing provides good burp-inducing support for the baby while freeing up one hand for doing things like trying to unscrew lids off bottles or tying shoes or reaching down from the steering wheel to shift gears. (Are you awake?) I usually perform The Right-Handed Chicken Wing, holding my forearm, vein side down, at about nipple height (the loosely-cupped hand as if in a position to milk the nipple, in fact) and roughly parallel to the ground. The baby’s bottom rests on the top side of the arm, and her chest and stomach rest on the shoulder. Jiggling the baby high up on the shoulder using this maneuver is sometimes good for inducing hard-to-produce burps, and the move affords the baby an unobscured rear view and the freedom to crane her neck around. Watch out, though — if she doesn’t have pretty good neck strength, she’s liable to go pitching over sideways in pursuit of a runaway head.

Because the high arm position necessary to perform a good Chicken Wing can cause arm fatigue, you will also want to learn The Modified Chicken Wing, or The Half Nelson. Again, I prefer the right-handed hold, and to switch to the modified hold, I simply open up the palm of my right hand to receive the fist of my left hand. The auxilliary (in my case, the left) arm should form an oblique angle with the primary arm so that maximum support can be had at a cost of minimum auxilliary arm fatigue. If there were no baby curled around your shoulder during this hold, you might bear some resenblance to eye-bulgingly flexing Hanz and Franz. Obviously, this maneuver ties up both hands. Accordingly, it is best used as an occasional companion to The Chicken Wing rather than as a primary hold.

I hope any fathers (or mothers — these holds have not been tested on mothers to my knowledge, incidentally; I suspect having bosoms would render the holds difficult) with other maneuvers to suggest will chime in.

On June 27, we left the hospital after delivering a beautiful baby girl by C-section on the 24th. Recovery was going well for Mleeka, and the baby’s just great. On July 11, Mleeka had a fever hovering between 102 and 103 in addition to some aches and pains and other unmentionable signs of something gone awry. She called her obstretrician, who sent us to the emergency room. Turns out she’s got an infected uterus. Or so says one doctor. A nurse says she doesn’t think that’s the case, given that infected uteruses (uteri?) tend to give off an odor pungent enough that it can be smelled in the hallway when patients’ doors are opened. And Mleeka is giving off no such odor. And then there’s the lower back pain. Sounds more like a kidney infection. At any rate, on top of an unexpected extended stay at a nice hospital for the delivery almost three weeks ago, we’re now in a grungier hospital for a minimum of two days while they drip antibiotics into her. I’m missing more work because she can’t be alone with the baby (hospital rules), who, fortunately, is allowed to stay with us in the room. Because Mleeka’s in no pain and because my vacation/sick time is dwindling rapidly and one of her sisters is available to babysit, I’m working a half-day today and may do so tomorrow if we can find another sibling to spend part of the day with Mleeka and Lennie.