Older blog entries for chromatic (starting at number 54)

I am stunned and saddened at the sheer amount of hostility some people claiming an interest in free software produce. Witness the public, unbridled rage against RMS with regard to the Python-requested evaluation of the language's 1.6 license. As the LinuxToday story points out (with a link to the Python License FAQ at BeOpen, I believe), the incompatibility has to do with an explicit locale of jurisdiction in the Python licence which RMS and FSF legal counsel believe to be at odds with the GPL.

One might think back to the ever-friendly jack-booted thugs bursting in on the Johansen household in Norway (wasn't it?) at the request of the ever-greedy wing-tipped thugs in the MPAA (that last A does not stand for Europe). One might wonder why jurisdiction matters, when a teenager in Europe might have to stand trial in another country altogether, especially as he is not a citizen of the latter.

Sociologically, I have wondered for quite some time if the reason the ancient Greeks and Romans had lusty and fallible (read, rather human) deities was to fulfill a universal human need to tear down icons and authorities by pointing out failings and hypocrisies. Perhaps I'm enforcing my worldview unfairly on the ancients, but that seems to explain the utter fascination with celebrity the last 25 years of Hollywood and the 'entertainment industry' have foisted upon an all-too-willing populace.

What does this have to do with RMS? I am starting to believe there is a subset of the population-marked-by-an-interest-in-free-software-and-free-software-issues motivated by this cannibalism. (Remember Cronos eating the Titans? ) The knee-jerk flame first and don't ask questions must be very draining. I'm fortunate enough to have avoided such controversy. (Truth be told, one would expect a Larry Ellison or Scott McNealy to attack RMS instead of a 14-year old hunched over IE during the lunch break at his Junior High school, signing every other post with phallic-enabled fowl "ASCII art".)

It goes both ways, too. I'm sure ralsina has received quite enough bile from irresponsible GNOME groupies just as RMS has received from KDE zealots. In fact, I wouldn't be surprised to discover a mercenary underclass holding to no ideal but "it's funny when I make people angry!"

While there are good reasons to disagree (let the best approach win on its own merits), I cannot condone this level of hostility. Why is it necessary? What does it add to the discussion?

Is there a way to return our forums and our lists to the land of civility?

I've started on a manual (to be published on the web) for a free software project. I won't name it, as they haven't sent a paycheque yet, but some of you have heard of it. I've generated a couple of patches so far.

Being paid to do this is good stuff.

Fearing that yesterday was the last day it would play in my area (which turned out to be correct -- and it only ran for a week!), I went to see Princess Mononoke yesterday.

Wow -- don't miss out.

Prompted by jlp, I unbroke the Jellybean homepage for Mozilla. XHTML is a little picky, even against the transitional DTD. Why is it that I'm willing to write code that writes code, but not willing to give up writing web pages with vim?

I finished the last article in my series. I don't want to think about how many pages I had to read for it. Yow.

Currently finishing up Camel 3, soon to start Administering Apache, on chapter 3 of Grokking the GIMP.

Maybe I'll look at the Rogue code again... or get back to testing Jellybean synchronization and data persistence. *sigh* Long week.

jlp has been hacking on a way to install Beanpacks at runtime. Our fairly-rewritten initialization method didn't provide a good way to do this, so he took one look at it and ran away. (Well, actually, he spent a while poking around in there, then complained.)

I did some object data persistence testing, and realized that I'd totally broken the POST handling in my last Engine updates. Oops. CGI.pm, while an impressive and highly useful module, is kinda complicated, and we're definitely on the fringe of where it's useful. Either way, I managed to find a decent compromise between actually working and not allowing evil cracker types to overrun memory by sending the OED or topography map data as form data. Now that works again.

It was on to refactoring the Beads (beanpack initializer) module after that. Yikes. It broke in various and sundry ways, under my careful tutelage, but came back together in a somewhat uglier but more modular fashion. It should now be possible for jlp to fulfill his life's dream of installing Jellybean Objects from remote servers at runtime, without having to restart the server. (My dream is to get Jellybean servers to communicate with each other, sending data back and forth. Eventually this might be something neat like XML-RPC. For now, though, it'll be something very uncomplicated.)

Yeah, I'm mentoring him. You should be mentored, unless you're mentoring someone. Or maybe everyone should mentor and be a mentor.

Everything I know about UUCP, I've learned from the new edition of O'Reilly's Linux Network Administrator's Guide. Tomorrow (the 29th) should have another article in my series go up at that other site. That'll get some traffic to my home page, get those essays read, that software downloaded, that resume out there to geeks who don't do hiring anyway (and who can read through all of the buzzwords and figure out that I'm barely qualified for what I'm doing anyway!).

Anyway.

After beating my head against walls of my own design (ObObscureRef: didn't Mike Roe do a song called self made trap way back in 1992?), I've managed to debug, objectify, document, comment, and package Parsermaker to my satisfaction.

You will need Perl 5 (probably 5_004 will work, but I know it is okay on 5_005 and newer) and ignorance of the proper BNF grammar format. (Familiarity with and fear of Parse::RecDescent helps, too.)

Have a looksee here. Test it, play with it, break it, fix it, just don't complain about it (much). There's some serious wheel-reinventing going on here, but I've learned a whole lot and it just might be simple enough to gain a niche somewhere.

I cleaned half of the files in one of the drawers of my filing cabinet today. It's much nicer now. I have the strange impression that my desire to throw out old junk and box up stuff I really ought to keep is subconscious preparation to move somewhere else.

Since there seem to be only two companies in the area that want a Perl guru -- and one of them I left a few months back for various reasons, it looks bad for wanting to stay here. More's the pity.

Maybe I'm just being narrow-minded, or going through pre-birthday angst again this year. Oh well!

My parser generator now passes my test suite, and generates substantially less-than-ugly code. (The ugliness test is to compare it to its parent. Yikes!) There is still some nice packaging work to make one beautiful Perl object, and there is one other potential optimization I can see right now.

The most beautiful part is that, for simple projects, this will do what I want. There are a few caveats , which I will document before releasing for public consumption, but it appears to meet my needs for Jellybean well enough that I can successfully say that I wrote something actually useful. Watch this space, if you're at all curious, because I'll put it on my homepage soon. (So far, I know tripp has read my diary in the past!)

Thanks, as usual, go to jlp, who is pretty good at pair programming or somesuch geographically-challenged approximation.

Flipping through Jon Udell's book again (go buy it if you program anything related to the web or people communicating with each other), I've decided to write some Jellybean stuff to synchronize data between invocations. (Yes, they're supposed to be on separate machines.)

This could be very handy if, as in the first example came to mind, I built a help-desk application on top of it. One master Jellybean server would collect open tickets. Techs would, at their leisure (or enforced interest), connect their Jellybean servers (er, clients in this context) to the master and grab a few tickets for themselves (based on certain criteria).

As an application, it's pretty simple, but it's an important proof of concept. One of the benefits of web-enabled applications (for that narrow scope of applications where the mediocre widget set is appropriate) is that access can be nearly ubiquitous. Now imagine your boss takes his laptop on a trip, and doesn't have Internet access for whatever reason. If you put a minimal web-enabled application service (like Jellybean) on his machine, he can work on what he needs to, and synchronize with a master server when necessary.

Running a minimal application service like this on a desktop probably has some uses, too... so we'll of course create yet another simple markup language that has some access to the underlying internals. (And I have some ideas on improving performance here, too.) Peer to Peer networking has to take off sometime. Why not try to build the killer application?

Programs that write programs are the happiest programs in the world... but the hardest to debug. Not only are there quoting rules involved (if you write in an advanced language), but the most self-evident way to check the original program is to see what's broken in the generated program.

Yow.

jlp and I spent an hour or so huddled in a chat, fixing this and that. What's frustrating is that the core Text::ParseWords module seems to have an extreme dislike for newlines, though we asked it ever-so-nicely to tokenize input, splitting on whitespace. Bah!

Okay, the first of my four articles went up over there yesterday. Expect the next one next Tuesday, and so forth. I'll have the final article finished by Monday, I promise. Or I don't. Don't despair, point a Linux newbie at one of these sometime and see what happens.

I updated a resume today on one of those really big resume sites. Is it false hubris to call myself a Master Perl Hacker? I'm no Damian Conway or Randal Schwartz, but I own books by both and understand 80% of what they say.

Where's a good place to look for a decent job that'll pay me what I'm worth (at least $5/hour) and treat me with more respect than I deserve?

Hooray, Sixpence None the Richer makes beautiful music.

True story. Years ago, I brought home their second CD (this beautiful mess) and my jaw actually dropped at the first chorus of the first song ('Angeltread'). It remained in said position well through the second song. I was hooked, and managed to pick myself up off the floor a couple of minutes after everything ended. To this day, there are few songs that give me chills. ('Jacksie' from Over the Rhine's Patience is one, and aforementioned 6pntr CD is chock full of others.)

It's times like this I wish my Music Performance degree weren't gathering dust, and that tracking software for libre operating systems were in better shape. Better get hacking, eh?

I sent off a mostly-finalized version of the parser generator to the other Jellybean hackers today. We'll see what's missing and add more to it in the next few days. It's pretty simple, and looks workable. Not too fast, but not too complicated either.

I also worked up a patch for mishan's peggdrop project. Now I feel like a real rogue Perl guru. He has some chromatic-style suggestions for internal reconstructions, easily ignored.

I have a stuffed Pikachu on my desk now, to go along with a Gothic water fountain (with gargoyles) and a couple of dozen cacti. Oh, and a metal camel sculpture I picked up in Bethlehem. COOL.

Wheat must know something about a link to Jellybean Central from a Wiki inside the Stormix domain. Referer logs are so fun! Too bad I don't have a Zope password, though that would present an interesting paradox.

wainstead, I'm positive the quote was "You... are... hearing... me... talk."

It's been sitting on my desk, nearly finished for a year. I got tired of waiting for the publisher to move things along, so I created a nice page and form to show off my recent work and to gather popular support for actually getting the book published sometime. If the eight of you who read this last time passed along the link (but only if you think it's good), the possibility of making $25 might inch us closer to the presses. Maybe there's a market for a book with a poem written in about six different computer languages.

No promises, though, because there's nothing -good- that rhymes with Advogato.

And besides all that, I decided to go bare-bones and try tie-ing a hash to a DB_File, instead of pulling out a full-bore database. Pretty simple stuff, if your needs aren't complex. Plus, the logo doesn't suck.

I hate calling people on the phone. I hate when people don't answer. I hate when people don't call back. I hate Ted Koppel.

No, wait. I just hate the telephone. I find Ted Koppel witty and entertaining.

Unless I've missed something really really stupid (and I've been known to do that once in a while), the basics are all there. I turned the List of Lists of ... Lists into a tree. It's not a classical tree, because there is no arbitrary number of child nodes. The important thing is not *finding* a specific node in the least amount of time, it's *following* all of the possible paths from the root to each leaf (one path per leaf, thank goodness!).

With the proper data structure (spake Fred Brooks, though he phrased it differently), writing the code is easy. jlp came to the rescue again, pointing out a silly little bug that had already consumed too much time. (Sidenote: there's something to this XP thing, even if my paired programmer would spend half the day asking "What in the world are you trying to do here?")

Anyway, now there's room for a little touch-up of the parser generator itself, and a lot of tweaking of the code it generates. Then it's on to writing an actual grammar (not the test one), seeing if it breaks things (possibly), then fixing them (hopefully, even probably).

Maintaining things isn't nearly as much fun as building them in the first place -- but knowing that what you've built actually works is quite a rush.

Oh, and never use scp to move tarballs from one machine to another if you have ssh compression enabled. Otherwise, you'll end up with files on the other machine that have '.tar.gz' names but are really plain '.tar' files. Whoops.

Bug in scp, or another questionable move on my part? You be the judge.

I really don't want to write yet another parser or two for Jellybean. Really really don't. Of course, I also don't really want to integrate bits and pieces of an existing system, unless it's an organicly seamless fit.

I really want to get the templating systems in place for Jellybean very soon. That, and a workable (if basic) object instance persistence system are the two things standing in the way of getting the rest of it built.

But see the first point, up above.

I did some experimenting with Parse::RecDescent yesterday, learning quite a bit about parsers and lexers in the process.

What attracted me initially was the idea that the module lets you dump its internal data structures and parsing system into a new module, capable of doing top-down recursive magic on anything that fits the grammar you fed it.

What disappointed me was that it's huge, it's more powerful than I need at this point, and it still depends on Parse::RecDescent. Adding lots of nifty-but-exotic dependencies to software intended for end users isn't high on my list of priorities at this point. (hence the section titles).

Yes, code reuse is a good thing, and there are a lot of great modules on the CPAN, but if I can get by with something simpler (even if I have to write it myself, I can always look at the module for examples and techniques), that reduces the installation burden and possibly memory and speed requirements.

Hopefully.

To that end, I found myself lying awake last night, alternately thinking about a tied filehandle scheme that applies a user-supplied regular expression to the input or output stream and writing my own parser generator. False laziness?

Ouch.

The lexer wasn't too difficult. My data structure doesn't seem to suck. The part I'm dealing with right now is attempting to optimize the possible execution paths for a rule set -- where you might define a Command as being Token, Token( Argument+ ), or Token Token+.

Obviously, the execution path can go something like a Command is defined as a Token followed by 1) nothing 2) ( Argument optionally repeated ) 3) Token optionally repeated. The first action for all three possibilities is to check if there's an initial token. From there, we can branch off.

So how do I get from a set of rules that look like the enumeration above into a Perl-ish data structure that I can walk and make into code? I've got a LoLo...L in mind, but it's the checking and collapsing part that escapes me at this awful hour.

So who said Perl hackers don't beat their heads against Computer Science now and then? If I'd only listened to the voices from the future, telling me not to study Music... blah!