Recent blog entries for bigbuba

Nice WM features

Dig the shnazzy MDI window manager UI on IntelliJ! It has two great features that would be wonderful for general window managing as well as for MDI.

The first is the ability to keep windows automatically tiled; growing one window shrinks the other, such that their borders stay stuck together. In today's world of big monitors and bigger resolutions, most simultaneous window work is best done with all windows completely visible. (For example, when I edit code in one window, consult a reference in another, and discuss it over IM in a third, it's now sensible to have no overlapping windows.) This style of MDI has none of the disadvantages of the traditional "window within a window" style; it's very clear what's going on, and windows never get "lost". It even handles minimizing one of the windows nicely, causing the other window(s) to grow to fill the newly available space. Maybe "maximize" could be overriden to give a tabbed interface :).

The second great feature is iconifying windows to fixed locations at the borders of the main window. This is wonderful, because unlike the taskbar model, it capitalizes on spatial memory. (e.g. My log viewing application is always the blue on an inch below the upper left corner of the screen.) You don't have to consciously remember where the representation of each task is, because your muscles will develop the habit of finding it. Of course, "corners of the screen" is just as good as "corners of the main window", and you could implement hiding behaviour so that these icons are aren't visible (or as large) until you mouse-over them.

Just like tab support in the window manager, this might be tough to implement. Anybody take that as a challenge?


Thanks raph, for the rss feed.

Really nasty things about perl

From Conway's Synopsis of Apocalypse 6:

  • Subroutines (keyword: sub)
  • Methods (keyword: method)
  • Submethods (keyword: submethod)
  • Multimethods (keyword: multi)
  • Rules (keyword: rule)
  • Macros (keyword: macro)

They've got to be kidding! Is complexity still only a matter of taste, that it can't be definitively demonstrated when it's a mistake?

Starting the blog with some random rants

Nasty things about wikis

It's funny that people are so excited about wikis, which employ nonstandard markup and are a step backward from the semantic web. What's more, wikis tout full public writability at a time when we should be thinking about and building reputation networks.

Wouldn't it make a lot more sense to implement the wiki on the browser end? The web server would just hand out static ".wiki" files, and have a simple cgi for posting new ones. Too bad we don't have better standard browser scripting. Maybe a javascript clientside wiki would be good.

Nasty things about blogs

I wonder how many blasted html template tools have been written in the last five years. It's a shame that blogs have been built on top of the traditional web and lurch so clumsily towards semantic web goals.

If blog builders focused a little more on comment structure compared to presentation, many semantic improvements could easily be made. For example, parts of comments could be marked up as being either summarizing or adding to referenced links. (Among other things, this would enable readable cross-blog threads.)

Nasty things about xml

OK, so the secret's out. No one likes the xml format. But that's fine, because everyone can work with it anyway, and that's all we ever really wanted. (Especiallly since reasonable apis are available e.g. pulldom.)

If xml is no more than a standard document exchange format, then why should the primary serialization of any language be xml? It's fine to want all the spiffy benefits that xml confers, but when is it ever important for a human being to author in raw xml? The only example that I can think of is for self-modifying xslt code to work just like plain xslt code, but is that really worth it?

Maybe this is an important idea to promote: write your human meaningful language first, and then write your machine meangingful xml serialization dialect. Having xml be a binary format would certainly encourage this (as well as discouraging programmers from individually disgorging poorly formed xml, instead of using a fast, free, and relatively bugless library).


I haven't figured out how I feel about publishing personal matter that may be applied out of context, so this blog will be pseudonymous for now.

New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!