Mathrick no PATANKO PRESS!

Just a quick drop: if you use paredit.el for editing in your Lisp buffers (as you should), and you happen to also use CUA-mode (which rocks, btw), you probably know that by default they don’t play together too well. Well, I’ve finally got fed up with that and wrote some glue to fix them up. Details and code can be had from this c.l.l post

Update: For some reason WP disabled comments when I first posted this. Fixed now.

There’s a thread on c.l.l going, in which people try to find a reason macros haven’t caught on for the past 30 years, despite their immense usefulness. One of the cited arguments was this statement by one of the men in charge of Java process:

The advantages of Java is that it easily serves as a lingua franca - everyone can read a Java program and understand what is going on. User defined macros destroy that property. Every installation or project can (and will) define its own set of macros, that make their programs unreadable for everyone else. Programming languages are cultural artifacts, and their success (i.e., widespread adoption) is critically dependent on cultural factors as well as technical ones.

My claim is that this is about as true as C++’s approach to performance, in which people copy things all the time, because that’s what manual memory management makes them do. Just consider the “design patterns” omnipresent in Java. What is a macro, if not a structured transformation of source, following certain pattern? Of course, I’m saying nothing new here, but I just stumbled upon a particularly good demonstration of why “macros decrease legibility of code” is utter nonsense. Consider this snippet:

(restart-bind
    ((retry
      (lambda () (throw 'retry nil))
       :report-function
       (lambda (stream)
         (write "Retry reading the record." :stream stream))))
  (catch 'ok
    (loop do
         (catch 'retry
           (throw 'ok
             (unless (read-record)
               (error "Record not available.")))))))

Just try analysing it, how fast can you find out what exactly it does? Aren’t braided catch/throws fun? Now consider the same snippet using a macro:

(with-retry (:report "Retry reading the record.")
  (unless (read-record)
    (error "Record not available.")))

Not only is the code 4x shorter and uses idiomatic naming conventions and code structure, the macro also comes with a docstring and parameters to let you easily influence the working. And most importantly, you only have to understand it once. Whereas in Java every time you encounter a similar-looking snippet, you have to analyse it to see if it’s actually the same thing, or subtly different.

So, to sum up with a checklist, the macroless code is:

• More verbose
• Really complex and confusing
• Hard to spot and identify reliably
• Not documented
• Must be re-invented each time you need it
• Does not ultimately prevent convoluted code from coming up. If your code needs retry functionality, then so it does, and no amount of “ours is a simple language for the masses” can change it. Though if you make it sufficiently painful, people will probably find ways to dillute the apparent complexity amongst modules, only compounding the problems, and/or pretend they don’t really need their program correct, because it’s such a massive PITA to do it.

Now, to be fair, this is not to say that macros can’t be hard — very often they are, because you generally use macros to solve problems that would be even harder without them. You don’t deny surgeons access to endoscopy because they might not be skillfull enough to handle it — instead you make sure they are or have to find another trade. There’s no reason to treat programmers differently.

Saying “macros make code unreadable” is like saying “race bets can only be done on manure-covered floor, or else you won’t know you’re dealing with horses”.

(with-christmas-gifts
  (visit family))
(setf *money* 0)
(print ";_;")

Working on a project with a rather deep directory hierarchy, I finally got tired of my prompt overflowing the line and wrapping around. So, here’s a handy bash function to put in your $PS1. It should be noted that I did not write it, I only wrapped it up in a function and added some aesthetic options, but all the hard work and bash hackery was done by BearPerson from #bash.

# Produces the same effect as \w in $PS1, but makes sure that the
# result length doesn't exceed $1 chars. If any dirs are omitted, they
# are replaced with [...]. Optional $2 turns on ANSI VT100 escape
# sequences to dim the [...] part. Optional $3 specifies the colour
# code to dim to (otherwise 02, "dim")
bound_pwd ()
{
    limit=${1:-40}
    ansi=$2
    colour=${3:-2}

    regex="~$|~?/.{1,$limit}$|/[^/]*$"
    pre=$([ $ansi ] && echo -n "\[\033[${colour}m\]")
    suf=$([ $ansi ] && echo -n "\[\033[0m\]")

    CANDIDATE="${PWD/$HOME/~}"
    [[ $CANDIDATE =~ $regex ]]
    [[ $BASH_REMATCH != $CANDIDATE ]] && CANDIDATE="$pre[...]$suf$BASH_REMATCH"

    echo $CANDIDATE
}

To use it, either put it in your .bashrc, or in a file that is sourced by .bashrc, then replace \w in your $PS1 with $(bound_pwd). Personally I use $(bound_pwd 25 1) to get at most 25 chars, with VT100 colour codes.

Obligatory screenshot:

Update: If you use VT100 colours, remember to surround the bound_pwd invocation with \[ \], otherwise non-printing characters will confuse bash and make it wrap lines incorrectly

Update 2: The above update was wrong. It’s actually more complex than that, and due to the fact that bash doesn’t exactly have coherent escaping semantics, I had to rework the function. If you use VT100 colours and have downloaded an earlier version of bound_pwd, you have to download it again, it has changed. Additionally, to have it really work, you have to add this function:

set_ps1 ()
{
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:'"$(bound_pwd 25 1)"'$ '
}

And in .bashrc, add this:

# Yes, it's silly that ; alone is not valid syntax
PROMPT_COMMAND="${PROMPT_COMMAND:-true};set_ps1"

Make sure it’s the last line to set PROMPT_COMMAND. Especially if you’re on Debian/Ubuntu, as their default .bashrc sets it conditionally.

Following up on my CGI-Lisp work, here’s a short recipe on how to route the entire Apache traffic to a CGI handler. This is not trivial because of a few problems that need solving:

1. mod_actions will fall into infinite loop if you try to associate a handler with <Location /> (as will mod_rewrite if you attempt to rewrite /.*)
2. mod_rewrite will not execute CGI scripts by default
3. mod_rewrite only serves physical paths under DocumentRoot (and it’s good practice not to have /cgi-bin/ under DocumentRoot)

These can be all solved, but require some searching and reading into the meaning of various options, so I’m posting a ready solution here:

<VirtualHost *:80>
    ...
    DocumentRoot /var/www/
    ...

    RewriteEngine On
    # PT means "passthrough" and will allow mod_rewritten URLs to be matched by
    # virtual locations, not just physical paths
    # T= specifies mime-type to ensure the CGI handler will be executed
    # sock.cgi is the handler we want to handle the entire traffic
    RewriteRule ^/(.*) /cgi-bin/sock.cgi/$1 [PT,T=application/x-httpd-cgi]

    ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
    <Directory "/usr/lib/cgi-bin">
        AllowOverride None
        #Add whatever options you normally use for your /cgi-bin/
        Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
        Order allow,deny
        Allow from all
    </Directory>

As an added bonus, it seems that the REQUEST_URI sent is the URL before rewriting, so you don’t have to do anything special to filter out /cgi-bin/sock.cgi from it.

Following the best agile methodologies, with rapid turnaround, short deliverables, tight customer feedback loop and probably something else involving “leveraging” and “assets”, I’m we’re proud to announce CGI-Lisp 0.5, the latest incarnation of the market-leading, award-winning product in the mod_lisp-compatible CGI-to-Lisp bridges space.

I call it 0.5 because I think it pretty much complete, but not enough to insist there are no bugs to be fixed or additions to be made.

Highlight of changes:

• POST now considered working. I haven’t actually done anything to make it so, but I tested it and mapped enough variables to have it actually useful (and it turns out to be working out of the box otherwise).
• Much more complete mappings. It should have most of the variables anyone cares about now.
• Tested a bit more. And by tested I mean “played with several Hunchentoot applications and found them not breaking horribly”.

I’m happy to announce the first release of CGI-Lisp. It’s a small hack that allows you to trampoline webserver requests into a long-running Lisp process, just like mod_lisp (and using the same protocol), except that it runs as a CGI handler. So you can run it on shared hosting.

The code was stolen from Rob Warnock, who hacked it years ago. I in turn hacked it into speaking unmodified mod_lisp, which allows it to be used as a drop-in replacement:

It’s been extensively tested by running it on exactly one machine in exactly one scenario. That means it will quite possibly break for you. If you still ain’t scared, grab the tarball here.

Update: so yes, I realise you hate GLib and can’t install it on your server. Debugging it was sufficiently annoying, though, for me not to be willing to put up with the sorry excuse for string handling of plain C. And I don’t think it will be very useful without handling POST anyway. I will probably fix that later on, but I don’t have the time now.

Update 2: I rewrote it not to require GLib. It’s slightly slower than before, but not much, and it’s good enough for me. POST non-handling still needs fixing though. You can grab the updated version from the same place.

Ladies and gentlemen, the C++ FQA Lite!

If you hate C++, you’ll have a great time reading this brilliant and amusing rant that rings just so true. Occasionally you’ll weep when it rings a little bit too true, invoking painful memories.

If you love C++, it’s a big flaming rant, but written with technical competence that easily shadows everything else out there that’s been written on the subject. You can’t claim any knowledge of C++ without having read it. And chances are that it’ll make you not love that sin against all good and just before it’s too late. Just think about it, the author is still trapped inside the warped world of C++, dealing with errors that have defeated everyone else on his team. The FQA is really a desperate cry from inside the asylum for you to stop while you still can. Think about it, you’ll be endlessly happier if you do.

If you don’t care about C++… Well, lucky you. But if you know someone who likes C++ more than they should (that is to say, at all), consider doing them a favour and pointing them to the FQA. Friends don’t let friends use C++.

In case you don’t know it yet: Peter Seibel’s Practical Common Lisp is the best Common Lisp tutorial around. It’s also a great book on its own, and a recommended reading for anyone looking to pick up a new programming language (and Common Lisp is a recommended language for anyone, too :). Go read it.

My personal method of reading is, as it lack traditional textbook problem sections, to follow along with the problem specifications, but not with the code, and only compare the results once finished. This was the way for me to avoid lazily reading, but not actually comprehending, the code.

Also, if you choose to read the web version (there’s a dead tree edition to be picked up from Amazon, y’know), you will want to install the greasemonkey script for footnotes hyperlinkification. And be sure to read it to the end, including all the practicals. A fair body of the code from the book got packaged into separate libraries and is actually used by many projects, this way you will be gathering knowledge of some very useful and widely employed packages.

And one final tip for any would-be Common Lisper: CLHS is your friend. Learn to read it today.

A new ccharset version is out, courtesy of LaC.

The installation and everything stay the same.

svn == ☹

svn + bzr-svn + merge-into == ☺ && ♥

bzr is SO the best damn Subversion client around. It’s also an awesomely shinytastic SCM in general. I now have two svn repositories, one imported into a subdirectory of the other, while still retaining the ability to intelligently pull in changes made in the upstream of the imported repo, all managed by bzr-svn. And it’s not just svn branches imported one time into bzr. Those are actual svn working trees still fully visible and valid to any old svn client. In other words, bzr is so fucking cool it actually fixes design flaws in subversion! Ain’t got nobody nothing on that level of integration, no sir.

_('of')

DEAR. GOD.

Yep. It’s not my accomplishment, mind you, I was too lazy and just got used to the shortcomings. So the new version of ccharset comes courtesy of teh_LaC. Here you can get it. Readme stays the same as in the old version, but bear in mind the config file is no longer compatible, so you’ll have to set channel encodings again. Ah, and topic setting doesn’t, and isn’t going to work, yay XChat.

So, I just realised the stuff I’m fighting with right now is screenshotable, so here you go:

The legend goes like this:

• the text is, well, text; it’s supposed to be stacked this way (and to get an actual vertical layout, you just rotate the cairo drawable).
• Colourful Boxes are bounding boxes, you can see how it gets a wrong idea of where the glyphs lie. This is because the rotation done on glyphs, and their origin point is in a corner, instead of the centre.

I’m currently trying to compensate for this, but that’s actually not easy, as PangoGlyphGeometry holds the width, but not height. So fixing horizontal shift is easy, vertical is not. Especially because there’s this bug where a valid (because it’s used one line below with no problems) pointer to PangoFont can’t be cast to GObject.

Update: So, yeah, taking an address of a pointer doesn’t always yield the desired results. But it still doesn’t really work, and Behdad is out to Barcelona, *grumble*.

Here’s another small xchat hack I wrote to add missing functionality: privflash. It makes private messages behave the same as nick highlight you get in channels, ie., blue highlight + taskbar flash. Why it isn’t like that in default xchat I dunno, but finally I got annoyed enough to fix it. One day I’ll also add some sane nick availability notification, current “notify: <nick> is online” is completely laughable, but that’s later.

PS. The usual drill to install it: needs python plugin, drop it into ~/.xchat2/, it’ll get picked up next time you start xchat, or /py load privflash.py if you don’t want to wait. Enjoy.

Wow, a post. A rare sight indeed. Anyway, I got accepted into this year’s SoC, with the project on making Pango support vertical writing. Coolness! There’s also some movement towards getting us (the students) to GUADEC, even though the registration process is formally over. Coolness too, especially if it works out.

Some other pimping I didn’t get around to before: My writing for IBM developerWorks went nicely, and in addition to the previously contracted series, I got to write 3 more articles. One of them is already up, this time our fine bindings guys get some love and fame. You might have noticed it’s published in “AIX and Unix” section this time, that was a kind of sekret projekt they got going on, which basically increased demand for new stuff, and by extension my opportunites to write something. I must say that writing on stuff you know and love is a joy, the only thing that sucks (besides my perennial ability to stick to schedules, sigh) is the hopelessly low word limit, I hate it with passion.

Ah, and since it’s apparently going to get syndicated by p.g.o, it’s a good place to ask: If you are in the GNOME Village and have some free places and are willing to host me, drop me a line. I need that to apply for sponsorship and to, well, have some place to crash at GUADEC :). I can be reached by the comments form or email, mathrick at gmail.com. Unfortunately my ISP is braindamaged and blocks outgoing mail, so mathrick.org is currently out of reach :(.

My calendar says it’s Dec, 21st today, which means it’s been one day since my article got published. Yay!

Introducing CCharset!
If you were ever annoyed by XChat’s perpetual inability to follow per-channel encoding settings, then be no more! CCharset allows you to override encoding on a per-channel basis, so now you can use iso-2022-jp in the ever stubborn #nihongo and utf-8 everywhere else. Isn’t that cool? It does exactly this one thing, manages your encodings, nothing else, particularly won’t spew stupid messages on all channels you’re on and fuck with your colours, unlike certain other plugins (coughfreecharcough). Also supports saving your settings, so you don’t have to ever enter that info more than once.

Of course, the usual disclaimer applies, so if this plugin runs over your cat, then sorry for the cat, but you have only yourself to blame.

Update: It has come to my attention that the plugin messes with non-ASCII topic setting badly. So there. You have been warned. I’ll probably (attempt to) fix it someday, but right now, it’s not a top priority.

reason #84.

(For those of us who need smart IME anyway, check out UIM, great stuff. Japanese and Polish diacritics at the same time are finally possible.)

Robsta, ugh, that hurts. This is one of the reasons I dislike C++[1]. Good that templates were too fresh of a thing for that document (2001 it says) to be used universally. The same effect, just stronger, seems to occur in Java. Not that I have anything against the language, but somehow, Java and (my private theory) the way its standard library is constructed tends to get the OO designer out of people, multiplied x10. Also, I think that because Java cannot be developed with without dedicated tools (because to get one, simple hello world app you need to create 10 directories, and running a simple jar is still a challenge, 10 years later), people go all the way and make it impossible to understand without dedicated tools. God forbid there’s anything like UML nearby, or we’re all doomed.

[1] And Mozilla/Gecko. I don’t know if that’s still the case, but to my knowledge, up until recently not all the string classes in the platform were frozen. Which means you cannot use strings and keep compatibility with future Geckos. Which means huge, gaping suckage the size of hallway.