What
 · Technology
 · · Dynamic Languages

Other Android Languages · I’ve been hav­ing this same con­ver­sa­tion with a va­ri­ety of pro­gram­mers in re­cent days, and so I ought to share it with the world. I think it would be nice if you could build An­droid apps in oth­er lan­guages. The lead­ing can­di­dates seem to be Ru­by and Python. Peo­ple are work­ing on it. This is my take on the state of play ...
[32 comments]  
D.P.H. · I owe a whole lot to Per­l. So does the prac­tice of com­put­ing in gen­er­al, and the con­struc­tion of the Web in par­tic­u­lar. Perl’s sit­u­a­tion is not ter­ri­bly hap­py; I wouldn’t go so far as to say “desperate”, but cer­tain­ly these are not its glo­ry days ...
[22 comments]  
Sssssssssssssssssssssssun · As any­body who watch­es this space knows, we’ve been pour­ing in­creas­ing amounts of love on dy­nam­ic lan­guages re­cent­ly. Wel­l, er, on Ruby, to be pre­cise. But you know, Ruby’s not the on­ly game in town. So, as of this morn­ing, not­ed Python­ista Ted Le­ung and Jython lead Frank Wierzbic­ki are join­ing Sun ...
[22 comments]  
Django on Jython · It’s start­ing to hap­pen. There’s a long way to go be­tween suc­cess­ful­ly ex­e­cut­ing a bit of Rails and ac­tu­al­ly mak­ing the suck­er run use­ful­ly, as the JRu­by guys will tell you. But speak­ing of JRuby, there are some eerie sim­i­lar­i­ties: a language-platform project that was promis­ing, then drift­ing, now re­vi­tal­ized. The ecosys­tem gets more in­ter­est­ing all the time. [Up­date:] Frank Wierzbic­ki re­ports that Jython is rockin’ & rollin’, it’s not just Djan­go. Good stuff!
 
Ruby News · Check out An­to­nio Cangiano’s The Great Ru­by Shootout, which ad­dress­es the vexed ques­tion of Ru­by per­for­mance, takes names and hands out num­ber­s. Damn in­ter­est­ing num­ber­s, too, if not ter­ri­bly sur­pris­ing. You want sur­pris­ing? Engine Yard, which al­ready em­ploys Ru­binius Guy Evan Phoenix, has just hired Ryan Davis and Eric Hodel to work on Ru­binius. Holy crap. That makes four Ruby-implementor teams with mul­ti­ple peo­ple grind­ing away at the prob­lem full time. This is what they call good news. Mean­while, the Mac cor­ner of the Ru­by World is glow­ing with scar­let Ru­by love.
 
R and P · I was read­ing Eric Rescorla’s First Notes on Djan­go, which men­tions in pass­ing that the IETF is re­build­ing its (cur­rent­ly pret­ty lame) tool­ing in Djan­go. A few pieces of in­fras­truc­ture that are im­por­tant to Sun are al­so in Python. Mean­while, Rails and Ru­by go from strength to strength in their world. It oc­curs to me that there might be a pat­tern here: Python for util­i­ties and in­fras­truc­ture, Ru­by for ap­pli­ca­tion­s. Ear­ly days yet, but it’s not com­plete­ly im­plau­si­ble.
[9 comments]  
PyPy · Yes­ter­day I got a pitch from Lau­ra Creighton, Sa­muele Pe­droni (who’s ap­peared here be­fore) and the rest of the PyPy team ...
[5 comments]  
Language Waves · I sup­pose I could have en­ti­tled this A Gen­er­al Model for Progress In Adop­tion of Pop­u­lar Pro­gram­ming Lan­guages. What hap­pened was, I was com­pos­ing a rant in­tend­ed for use in an in­ter­nal dis­cus­sion of de­vel­op­er fu­tures, and it dawned on me that there’s a re­peat­ing pat­tern in the waves of pro­gram­ming lan­guages that man­age to suc­ceed in find­ing broad us­age ...
[14 comments]  
Pattern? · I can’t help but no­tice that two re­al­ly im­por­tant new pieces of de­vel­op­er in­fras­truc­ture in­side Sun have some­thing in com­mon. OpenJDK and lots of oth­er pieces of the ecosys­tem are us­ing Mer­cu­ri­al for source-code man­age­men­t. Then there’s the new OpenSo­laris Image Pack­ag­ing Sys­tem (think ap­t). The thing is, they’re both in Python.
[7 comments]  
On PHP and Ruby · Check out Matt Mullenweg’s On PHP, which takes a fair­ly caus­tic look at the (s­low, stalled in many places) tran­si­tion from PHP4 to PHP5. The com­ments are in­ter­est­ing, too. Some­time in the next cou­ple of years, there’s ac­tu­al­ly go­ing to be a Ru­by 2, and the Ru­by and Rails com­mu­ni­ties will de­cide, prob­a­bly with­out much con­sid­er­a­tion for the Ru­by implementors’ feel­ings, whether or not to take the step. There’s a fair­ly widespread feel­ing that, as a piece of lan­guage de­sign, the cur­rent Ru­by (1.8.6) is more or less Good Enough. The Uni­code han­dling needs to be fixed, and the li­braries need some work here and there, and I see Charles Nut­ter propos­ing plausible-sounding lan­guage changes which would be in­vis­i­ble to 99% of de­vel­op­er­s; but there’s no big com­mu­ni­ty out there wait­ing hun­gri­ly for the next Ruby. A ver­sion that was a lot faster would be snapped up PDQ you betcha, but few would care much about the ver­sion num­ber. So I think the Ru­by com­mu­ni­ty as a whole would ben­e­fit from read­ing the con­ver­sa­tion Matt start­ed, as we try to head in­to the Ru­by 2.* fu­ture. I per­son­al­ly think “runs faster and does Uni­code right” will prob­a­bly do the trick, but let’s see.
[3 comments]  
Ruby News · And is there ev­er a lot of it. I was go­ing to break this in­to a hand­ful of tar­get­ed snip­pet­s, but any­one who cares about the lan­guage would read ’em all any­how. Thus, an il­lus­trat­ed tour through Tokyo con­fer­ences, JRu­by 1.0, Re­fac­tor­ing, and M17n ...
[3 comments]  
Twitter, Rails, Seaside, Respect · If you’re ob­ses­sive about dy­nam­ic lan­guages and Web frame­works (and who isn’t?) it’s been a juicy few days. Let’s start with a bunch of point­er­s: Mike Pence in­ter­views Avi Bryant & tries to start a fight. Avi says “huh?”. DHH too, in his own space and an In­foQ in­ter­view. At the same time, a Twit­ter de­vel­op­er diss­es Rails. DHH says smart things and so do Kel­lan of Laugh­ingMeme and Ryan To­mayko. Phew. Now it’s my turn ...
[9 comments]  
Tech Tab Sweep · I break with my no-underlying-theme theme and do an all-technology tab sweep; in fac­t, al­most all XML ...
[8 comments]  
Groovy Flickr Escape Hatch · In the mail from Man­ning this week, Groovy in Ac­tion, nice­ly timed to fol­low up on the 1.0 re­lease. I still haven’t made up my mind about Groovy, so I’m watch­ing the com­mu­ni­ty with in­ter­est. For ex­am­ple, Alex Brown’s Bulk Pro­gram­mat­ic Con­ver­sion of Pho­tos from flickr to SmugMug. There are a bunch of in­ter­est­ing is­sues all mixed up here: Yahoo’s iden­ti­ty ploy, wildly-contrasting Web pro­gram­ming in­ter­faces, choos­ing from the lengthy list of Ja­va XML-processing al­ter­na­tives; and of course, watch­ing Groovy at work. I have to say the source code is re­al easy to read; odd­ly, what it makes me wish for is regex lit­er­als in Java. Hm­m, it’s not ob­vi­ous to the ca­su­al eye when you de­clare vari­ables and when you don’t; I’m sym­pa­thet­ic to the optional-declaration idea though. I guess I’ll have to have a look at the book; it was crack­ing the Pick­axe book’s cov­ers that dropped me on­to the slip­pery Ru­by slope.
[1 comment]  
JRuby News · Check out Charles Nutter’s blog for some in­ter­est­ing tech news on con­nect­ing to Ja­va. Even more in­ter­est­ing, they’ve added a new com­mit­ter to the team: Ola Bi­ni; he seems to be a cod­ing ma­chine. I’ve been gen­er­al­ly very im­pressed by the en­er­gy and in­tel­li­gence on dis­play in the mail­ing lists. Un­less I’m re­al­ly wrong, this tech­nol­o­gy has legs.
 
Oooh, Cédric · That’d be Cédric Beust, who, writ­ing both in my new com­ment sys­tem and his own space, de­claims “The bot­tom line is that IDE’s for dy­nam­ic lan­guages will *n­ev­er* be able to per­form cer­tain refac­tor­ings, such as renaming” and asks “Who wants a refac­tor­ing IDE that ‘works most of the time’?” He clos­es with a ma­jor dynamic-language dis­s: “I'm con­vinced that they are not suit­ed for large-scale soft­ware development”. Ob­vi­ous­ly a fun-loving fel­low. Geek girls and boys, I think that man is get­ting in yo face.
[21 comments]  
Dynamic-Language IDEs · I was read­ing Pat Eyler’s in­ter­view with the JRu­by guys (that’s part 2, Part 1 is good too); and I had an idea about build­ing IDEs for dy­nam­ic lan­guages like Ruby ...
[20 comments]  
Other Languages · Fol­low­ing on our hir­ing the JRu­by guys, I’ve had emails and links from rep­re­sen­ta­tives of pret­ty well ev­ery oth­er dy­nam­ic lan­guage: Groovy, Python, Pnuts, you name it. All of them say­ing, more or less: “Why Ruby? There are oth­er lan­guages which are bet­ter (or better-integrated, or faster).” Some of them would like jobs (per­fect­ly rea­son­able, we like get­ting that kind of email) and some of them would like Sun to as­sign mon­ey and re­sources to their lan­guage project (we like to hear about those ideas, too). So if you think those things should hap­pen, I rec­om­mend look­ing at the JRu­by sit­u­a­tion for lesson­s. First, these guys took an ex­ist­ing semi-dormant project and brought it alive, un­prompt­ed, un­paid, ap­ply­ing en­er­gy and en­gi­neer­ing skills to the prob­lem in large quan­ti­ties. Se­cond, they were work­ing in a field that has a large and grow­ing com­mu­ni­ty; in this case be­cause of the hype around Rail­s. Third, they were vo­cal and outward-facing and ar­tic­u­late, get­ting on the stage at Ja­va One and lots of oth­er events with im­pres­sive de­mos. Fourth, they shipped code that worked pret­ty well and im­proved qual­i­ta­tive­ly from re­lease to re­lease. I’m not sure it’s Sun’s role to pick and choose the win­ners and losers in this space, or anoint lead­er­s; what would make us think we’re that smart? But when ob­vi­ous lead­er­ship emerges in an in­ter­est­ing space, why wouldn’t we get be­hind it?
 
JRuby Love · Charles Nut­ter and Thomas Enebo, bet­ter known as “The JRu­by Guys”, are join­ing Sun this mon­th. Yes, I helped make this hap­pen, and for on­ce, you’re go­ing to be get­ting the Sun PR par­ty line, be­cause I wrote most of it. [Up­date: It strikes me that thank-yous are in or­der. Giv­en that Sun is in the pro­cess of (ap­pro­pri­ate­ly) slash­ing some of its en­gi­neer­ing group­s, new hires are a lit­tle trick­y. A lot of peo­ple helped, but I think the biggest con­tri­bu­tions were from our Soft­ware CTO Bob Brewin and es­pe­cial­ly Rich Green, who ap­proved the re­qs about fif­teen sec­onds af­ter Bob and I raised the is­sue.] ...
 
The Ruby Ape Diaries · I took tons of notes while I was work­ing on the Ape. I was go­ing to hold off pub­lish­ing till I re­leased the code, but once I ac­tu­al­ly launched the for­mal Sun pro­cess to do that, I dis­cov­ered that it can take two or three week­s, and so I de­cid­ed to go ahead while it was fresh in my mind. Un­for­tu­nate­ly, the piece pret­ty soon had fif­teen dif­fer­ent sec­tions and would have been too long for mere mor­tals with jobs to read, and fur­ther­more, the sec­tions didn’t have much to do with each oth­er, and there just aren’t that many peo­ple on earth who’d be in­ter­est­ed in all of them. Some of them look close at the is­sues of mak­ing Ja­va and Ru­by get along, while oth­ers wal­low in duck-typing per­ver­si­ty and fin­er points of Ru­by style. So I’ll keep them short and do one a day (or so) for the next week (or so) and fill a ta­ble of con­tents in here.
I. Why JRuby?
II. Back to Ru­by
III. Quack Like a URI
IV. TMTOWTDI
V. << !!
VI. Ja­va APIs from JRu­by
VII. J?REXML
VIII. Sur­face Phenom­e­na
IX. Those Li­braries
X. Mak­ing Markup
XI. Where To?

 
RAD XI: Where To? · [RAD stands for Ru­by Ape Diaries, of which this is part XI.] I think this con­cludes the Diaries, al­though on­go­ing al­ready has a cou­ple of five-part trilo­gies. The Ape works rea­son­ably well and is get­ting quite a bit of use; Sam Ru­by has con­vinced me that, rather than whit­tle away at the to-do list, I ought to fig­ure out a way to build a large cat­a­log of prob­lems and edge cas­es, test-suite style, in such a way that you can add new ones with­out writ­ing code. I haven’t yet fig­ured out how to do it. My Ru­by is still not ful­ly id­iomat­ic but it’s bet­ter than pidg­in, and there’s a re­al pos­si­bil­i­ty that the next time I get my back to a wall and need to do some­thing to a few mil­lion lines of text right now, I may not use Per­l. It should be rea­son­ably ob­vi­ous that I like Ruby. Stil­l, there are flies in the oint­men­t, worms in the ap­ple, fake jew­els in the shop win­dow ...
 
RAD X: Making Markup · [RAD stands for Ru­by Ape Diaries, of which this is part X.] If you’re writ­ing Web app­s, and even if you’re one of the few who isn’t, you’re prob­a­bly go­ing to have write code to gen­er­ate markup, HTML or XML. His­tor­i­cal­ly, pro­gram­mers have found this dif­fi­cult, and thus there are lots of li­braries that try to ab­stract markup away be­hind code (for ex­am­ple, my own Genx). There are tricky is­sues and trade-offs here, and Ru­by throws them in­to pret­ty sharp fo­cus ...
 
Spolsky Starts a Language War · In Joel Spolsky’s new Lan­guage Wars, he ar­gues that .NET, Java, PHP, and maybe Python are the safe choic­es if you’re go­ing to build out a Web app that’s re­al­ly big and re­al­ly crit­i­cal. He ices this cake with a shov­el­ful of clas­sic FUD aimed at Ru­by and Rail­s. Not sur­pris­ing­ly, David Heine­meier Hans­son vol­leys back twice with Fear, Uncer­tain, and Doubt by Joel Spol­sky and Was Joel’s Wasabi a joke? Bruce Tate has a more thought­ful re­sponse over at In­foQ: From Ja­va to Ruby: Risk. You may not agree with all of Bruce’s points, but they’re well ar­gued. It may sur­prise some who’ve en­dured the flood of Ruby-red writ­ing around here re­cent­ly, but I think Joel’s cor­rect that Python is quite a bit bet­ter proven than Ruby; and al­so that Ru­by has a big Uni­code prob­lem. But I can’t get around the fact that Joel sounds ex­act­ly like a main­frame droid talk­ing about Per­son­al Com­put­er­s, or a VMS droid talk­ing about Unix, or an EDI droid talk­ing about the We­b, or a C++ droid talk­ing about Java. Yeah, the new thing is kin­da un­proven and kin­da shaky in places and kin­da slow and not very full-featured. But it’s got ease-of-use ad­van­tages and programmer-productivity ad­van­tages and de­vel­op­ers like to use it. See the Tech­nol­o­gy Pre­dic­tor Suc­cess Ma­trix, and par­tic­u­lar­ly the last three cri­te­ri­a: Hap­py Pro­gram­mers, Tech­ni­cal Ele­gance, and es­pe­cial­ly the 80/20 Point. Joel’s prob­a­bly wrong.
 
RAD IX: Those Libraries · [RAD stands for Ru­by Ape Diaries, of which this is part IX.] Ruby’s de­bug­ging fa­cil­i­ties, com­pared to what IDE users like me are used to, are, well... sin­cere. At one point dur­ing the Ape work, I had a bug that was re­al­ly driv­ing me crazy. The symp­tom was that my HTTP in­ter­ac­tion with the serv­er would just freeze up, and I couldn’t spot the pat­tern be­hind it. It’s a fact of protocol-testing life that this par­tic­u­lar kind of shit hap­pen­s. Some­times you’re re­duced to de­bug­ging with print state­ments, and I was. But af­ter a while they weren’t help­ing me, I was call­ing Net::HTTP#s­tart on an apparently-valid con­nec­tion and then... noth­ing. Even­tu­al­ly, I was driv­en to look­ing in the li­brary source, net/http.rb. Hey, it was easy to un­der­stand! (Have I talked about Ru­by and read­abil­i­ty be­fore?) I could see where my re­quest was go­ing, but I couldn’t see how it could go wrong. Wel­l, this is a dev ma­chine, and Real Men de­bug with print state­ments. So in they wen­t... right in­to the Ru­by dis­tro li­braries, I mean. And I ran it again. On­ly took a cou­ple of min­utes to ze­ro in the prob­lem; in this case, a JRu­by bug. I’m not sure what the les­son is... but the code spelunk­ing was fright­en­ing­ly easy. This is not typ­i­cal of oth­er peoples’ HTTP li­braries; I have bit­ter mem­o­ries of bash­ing my head to a bloody pulp against LWP back in the last mil­len­ni­um. Did I men­tion read­abil­i­ty? [Ed. Note: You’ll be hap­py to hear that there are on­ly a cou­ple more RAD en­tries in the pipeline, then I’ll be done.]
 
RAD VIII: Surface Phenomena · [RAD stands for Ru­by Ape Diaries, of which this is part VIII.] Pro­gram­ming is sup­posed to be an en­gi­neer­ing dis­ci­pline, or maybe a branch of math­e­mat­ic­s. But, as Don Box mem­o­rably said: “the on­ly peo­ple who should do it are those who can't not do it”, call­ing us “those few peo­ple who ab­so­lute­ly must live in the world of ex­e­cutable abstractions”. One con­se­quence is that we’re pas­sion­ate about the con­tent and the for­m. Here­with some re­marks on ap­pear­ances; the way Ru­by code looks and how you store it and so on; is­sues as im­por­tan­t, per­hap­s, as any oth­er ...
 
RAD VII: J?REXML · [RAD stands for Ru­by Ape Diaries, of which this is part VII.] In na­tive Ruby, the de­fault way to do XML pro­cess­ing is via the REXML li­brary. In JRuby, you have an­oth­er de­fault choice—Java’s built-in XML APIs. Nei­ther op­tion is that great. Stil­l, there are some rea­son­ably safe ways to get the job done. I wrote some glue code called JREXML to make the Ja­va APIs look more like REXML, which forced me to think about this stuff per­haps more than is en­tire­ly healthy ...
 
RAD VI: Java APIs from JRuby · [RAD stands for Ru­by Ape Diaries, of which this is part VI.] The rea­son I first built the Ape in JRu­by was so I could get at all those nice Ja­va APIs, and that turned out to be a good rea­son. Of course, there is a bit of im­pe­dence mis­mach, and I end­ed up writ­ing some glue code. I kind of sus­pect that, should JRu­by catch on, there’s go­ing to be scope for quite a bit of this glue-ware. This frag­ment is just a few ex­am­ples of the gen­re, to pro­vide ex­am­ples and per­haps pro­voke thought ...
 
RAD V: << !! · [RAD stands for Ru­by Ape Diaries, of which this is part V.] If you look at Ru­by code, you keep see­ing this lit­tle two-character mo­tif <<, and maybe ev­ery­one else al­ready knew about this, but it sure feels like mag­ic to this farm boy from the Prairies. Bonus: Lisp spec­u­la­tion ...
 
RAD IV: TMTOWTDI · [RAD stands for Ru­by Ape Diaries, of which this is part IV.] That glob of let­ters in the ti­tle stands for “There’s More Than One Way To Do It”, and it comes from Perl cul­ture. It is a dis­tin­guish­ing fea­ture of Perl that if there’s some­thing you need to do, not on­ly does Perl have a way to do it, it has lots of dif­fer­ent ways. Perl’s le­gion of evan­ge­list­s, led by Lar­ry Wal­l, ar­gue that this is an ad­van­tage. Lar­ry has a com­pelling ar­gu­ment by par­al­lel with lin­guis­tic­s; nat­u­ral lan­guages usu­al­ly have many ways of say­ing any­thing that’s worth say­ing. Not ev­ery­one agrees that this is a virtue; in par­tic­u­lar, Python­istas have his­tor­i­cal­ly grum­bled. Ru­by seems to fall in­to the Perl cam­p. And now, dear read­er­s, I must con­fess to a bit of du­plic­i­ty. When I wrote RAD III: Quack Like a URI, I knew that my ex­am­ple was per­haps not the purest pos­si­ble ex­am­ple of duck typ­ing, but my hid­den agen­da, name­ly gath­er­ing ma­te­ri­al for a TMTOWTDI es­say, worked out well ...
 
RAD III: Quack Like a URI · [RAD stands for Ru­by Ape Diaries, of which this is part III.] This lit­tle il­lus­tra­tion of a pro­gram­ming id­iom is sole­ly de­signed to hor­ri­fy new­com­ers from the Ja­va world, and will look mun­dane to ex­ist­ing Ruby­ist­s. Prob­lem: I want to check a URI to make sure it’s ap­pro­pri­ate for use in the Atom Pro­to­col, and if not, re­port a co­her­ent er­ror mes­sage ...
 
RAD II: Back to Ruby · [RAD stands for Ru­by Ape Diaries, of which this is part II.] As of to­day the Ape is on Ruby, not JRuby; read on for the sad sto­ry and the Ape’s ad­dress ...
 
RAD I: Why JRuby? · [RAD stands for Ru­by Ape Diaries, of which this is part I.] To build a val­ida­tor you need an HTTP en­gine and an XML parser, both of which Ru­by is ad­ver­tised as hav­ing. JRu­by, when I first took this on, was as at re­lease 0.9.0 and had plen­ty of rough edges. But I de­cid­ed to use it any­how ...
 
OSCON—Perl & Python · I man­aged to at­tend most of both Gui­do van Rossum’s talk on Python 3000, and Lar­ry Wall with Dami­an Con­way on Perl 6. It’s re­fresh­ing to look at tech­nolo­gies that have passed that tenth birth­day that seems to be cru­cial for soft­ware to es­tab­lish that it’s re­al, and to see that they’re liv­ing and squirm­ing and grow­ing. Python, per its cul­ture, seems to be tread­ing a straight-and-narrow path on a well-defined sched­ule guid­ed by a ruth­less­ly ra­tio­nal set of de­sign cri­te­ri­a. On a tech­ni­cal note, Python 3 will have a String type that is 100% Uni­code and that’s all it is, and sep­a­rate­ly a byte-array type that lets you in­dulge your most squalidly-perverse bit-bashing fan­tasies. I ap­prove. Per­l, on the oth­er hand, is whim­si­cal and wit­ty and un­sched­uled and blithe­ly dis­re­gards many gen­era of con­ven­tion­al wis­dom. One could eas­i­ly have con­clud­ed, lis­ten­ing to Lar­ry and Dami­an, that the prob­lem with pre­vi­ous ver­sions of perl was that they didn’t have enough syn­tax, and thus there was an ur­gent need to add more. It ill be­hooves me to diss Lar­ry Wall’s lan­guage de­sign­s, since I have suc­cess­ful­ly in­ter­nal­ized all but the most per­verse (type­glob, blec­ch) of those that are here to­day and they have en­abled me to wran­gle large amounts of da­ta in sur­pris­ing­ly lit­tle time with generally-popular re­sult­s. Noth­ing would warm my heart more than Perl 6 leap­ing to the cen­ter of the dynamic-language stage and re­claim­ing mind­share. The jury’s out.
 
On Ruby · I have pre­vi­ous­ly ad­mired the Ru­by lan­guage, al­beit from a dis­tance, and been im­pressed by the vig­or of the Rails com­mu­ni­ty. In the last week I have writ­ten a few hun­dred lines of Ru­by code that ac­tu­al­ly do some­thing use­ful and I’ll prob­a­bly re­lease (come see it at OSCON); so now I’m some­what bet­ter ed­u­cat­ed ...
 
Rubies and Pearls · I’m still feel­ing my way in­to this com­ments sys­tem, but my first days with Ru­by are mak­ing me think back a dozen years or more, to when I was learn­ing Per­l. It was a big data-filtering job and Michael Leven­thal had pulled to­geth­er a very typ­i­cal Perl bundle-of-regexps and sud­den­ly one day I was pitch­ing in on han­dling more types of in­put da­ta and pulling out more struc­ture. Lar­ry Wall, the au­thor of Per­l, is a lin­guist by train­ing, and is proud of the fact that with Per­l, as with a nat­u­ral lan­guage, you don’t have to be an ex­pert to be ef­fec­tive Just as a child de­rives val­ue from us­ing English even if in­ex­pert­ly, a novice Perl pro­gram­mer starts be­ing re­ward­ed quick­ly. Other lan­guages have this char­ac­ter­is­tic to a greater or less­er de­gree; and I’m be­gin­ning to think Ru­by is right up there. (For me, Ja­va had it too, as it would I think for any ex­pert C pro­gram­mer com­fy with O-O think­ing.) At the mo­men­t, there are lots of Ru­by id­ioms that are still gib­ber­ish to me; but I find two cru­cial things: my pid­gin Ru­by is al­ready pret­ty use­ful for get­ting things done, and I’m learn­ing new trick­s.
 
Grains · We push tech­nol­o­gy along slow­ly, gain­ing a bit here and a bit there. Most im­prove­ments, in any­thing, are in­cre­men­tal; the big ad­vances, ev­ery one of ’em, are root­ed in the fer­tile soil whose grains are all those lit­tle steps for­ward. Here are a few grain­s. Item: Bruce Eck­el squeezes XML in­to a sin­gle Python class. Item: Niall Kennedy pulls to­geth­er all the syn­di­ca­tion specs you might need; for ex­am­ple see atom­.feed­spec­s.­com or itunes.feed­spec­s.­com. Item: Peter Thomas pulls to­geth­er a spine-chilling graph­ic map­ping what hap­pens around a Hiber­nate storeItem cal­l. Ques­tion: is what this pic­ture shows a prob­lem or not? Item: Charles Nut­ter push­es the JRu­by Gems along, in­ter­est­ing­ly (and read the com­ments).
 
Go Visit Phobos · Hey, I see that Rober­to has pushed some ac­tu­al soft­ware bits to the Pho­bos site. Pho­bos is a server-side script­ing frame­work that runs on the Ja­va plat­for­m. Right at the mo­men­t, it’s all JavaScrip­t, but the hooks are there to wire in oth­er lan­guages. I’ve been a ma­jor Pho­bos cheer­lead­er for a year or more in­side Sun, but my on­ly ac­tu­al con­tri­bu­tion is the as­tro­nom­i­cal lo­go. There were peo­ple here who were con­sid­er­ably am­biva­lent about show­ing Pho­bos to the world, and for good rea­son; they asked “What is Pho­bos, actually?” and won­dered about its re­la­tion­ship to the rest of GlassFish. I’m not 100% sure what Pho­bos is my­self, but it’s in­ter­est­ing as a thought ex­per­i­men­t, show­ing that you can do the kind of lightweight zero-deployment things that peo­ple don’t think Ja­va does. The Red­dit/Do­jo mashup de­mo is se­ri­ous­ly cool. Fi­nal­ly, while the server-side JavaScript no­tion is pret­ty weird, go have a look at the code; writ­ing an AJAX app all in one lan­guage is se­duc­tive on the face of it.
 
Canada on Rails · As I was pick­ing up my badge from the slinky black-cocktail-dress-wearing wom­en (huh?) at the reg­is­tra­tion desk, this guy came run­ning up say­ing “We’re sold out! Don’t sell any more!” And the con­fer­ence was packed, all right. Here­with notes on DHH’s keynote, the crowd, and BDD from Dave As­tel­s ...
 
Rails in Vancouver · It turns out they’re hold­ing what’s ad­ver­tised as “the first ev­er 100% Ru­by on Rails event in the world” right here in Van­cou­ver, April 13-14: Cana­da on Rails. I’ll go for sure. Giv­en the en­thu­si­asm that built up around that PHP piece, I’m think­ing that a com­ment sys­tem for on­go­ing is in­evitable, and maybe RoR is just the tick­et. [Snick­er... the URI of the reg­is­tra­tion page ends in .php].
 
LAMP and Java · Take a minute and read Stephen O’Grady’s write-up, which starts at the Sun An­a­lyst Con­fer­ence, but says a bunch of things about Ja­va and LAMP and re­lat­ed sub­ject­s. I’ve been think­ing about this stuff al­most all the time for the past year or so, so let’s take his ideas a bit fur­ther ...
 
Ruby on Rome · In that re­cent Ru­by piece, I re­marked that Ru­by thread­ing struck me as kind of fee­ble, and that thread­ing is get­ting re­al im­por­tan­t. Wel­l, I know one way to solve that prob­lem. So I tracked down JRu­by geek Tom Enebo and got some news and he point­ed to me to some code that I think is pret­ty cool ...
 
Shiny Red Rock · It’s about That Lan­guage. All the soft­ware fash­ion slaves will tell you: down on the plan­ta­tion, Massa’s new mis­sus is a far-Eastern belle named Ruby. Here­with Ru­by re­mark­s: on the Pick­ax­e, slick­ness, lan­guage learn­ing, and duck­stat­ic typ­ing ...
 
More Dynamic Java · Check out this Java-to-Javascript “Hello World” from A. Sun­darara­jan. While I al­ways knew that there was of­fi­cial “scripting language” sup­port com­ing in the form of JSR 223, I saw it for the first time last week too; and it looks like it’s ac­tu­al­ly go­ing to be gener­i­cal­ly use­ful in a lot of dif­fer­ent places, and not just with Javascript ei­ther.
 
Project Coyote · Its goal is dy­nam­ic lan­guage sup­port in NetBeans, and it’s open for busi­ness over at Java.net. Check it out ...
 
Dynamic Java · It’s pret­ty clear that dy­nam­ic lan­guages are a hot area, maybe the hottest, in the world of soft­ware de­vel­op­men­t. We need to do more to make them eas­i­ly us­able by peo­ple in the Ja­va ecosys­tem. So on Tues­day we held a sum­mit here at Sun, with a few of our in­ter­nal Ja­va lead­er­s, and on the dynamic-languages side, Lar­ry Wall and Dan Su­gal­s­ki (Perl and Par­rot), Gui­do van Ros­sum, Sa­muele Pe­droni and Sean McGrath (Python), and James Stra­chan (Groovy). It was an ed­u­ca­tion­al day for us; here­with some take-aways and pic­tures ...
 
Jython · I was on the phone this morn­ing to the Ital­ian part of Switzer­land, talk­ing to Sa­muele Pe­droni, cur­rent­ly chief priest in the Jython tem­ple. I think Jython is re­al im­por­tan­t, which means that I think Sa­muele is im­por­tan­t. But on­ly if you care about Java ...
 
author · Dad · software · colophon · rights
Random image, linked to its containing fragment

By .

I am an employee
of Amazon.com, but
the opinions expressed here
are my own, and no other party
necessarily agrees with them.

A full disclosure of my
professional interests is
on the author page.