Search Results: "xam"

31 October 2005

MJ Ray: October oddities

Tomorrow (1 November), there's a protest against the Norwich Northern Distributor Road (N25) taking place in... Ely... which seems to be where the powers that be decided is a good place for the public examination of the east of England plan. It would make too much sense to hold it in any of the main cities, wouldn't it? On the plus side, Ely is a main railway junction, so maybe people will turn out despite the terrible roads to it.
"* poof... Clippie appears * It looks like you're trying to type a job advertisement. Shall I ..."
-- darsh, replying on-list to the day's third spam
"H5N1 BIRD FLU BELIEVED TO BE FIRST VIRUS UNABLE TO SPREAD THROUGH MICROSOFT OUTLOOK Researchers Shocked to Finally Find Virus That Email App Doesn't Like"
-- Mock news release forwarded to ALUG by Tony

29 October 2005

Erich Schubert: Ridiculous software patents encumber XML

So there is another example on bad software patents out. A company now claimed to own patents on the basics of XML (oh, and what about HTML, SGML etc.?). This is just another example on how bad software patents can be. It's outright ridiculous on what patents are filed nowadays. The US really need to get rid of them, and the EU should avoid introducing them over another backdoor initiative... I'd point out the British Royal Society for the encouragement of Arts, Manufacutres and Commerces "Adelphi charter", which is pretty clear on patents on computer code and abstract ideas...

Clint Adams: Some things are just Mormonic

Steve: I seem to remember that one can write a more functional HTTP server in fewer lines of Z-Shell code. Benjamin: As I understand it, Orson Scott Card is the problem. I'm sure other people can point to examples in his writing which illustrate poor judgment; I will stick to the topic at hand. Orson Scott Card has reportedly expressed his belief that Jake Lloyd is a fine actor. Orscon Scott Card has expressed his wish that Jake Lloyd play Ender in the movie. In case you are reading this with some program that strips hyperlinks (be sure not to miss the changelog for version 1.5.7), I'll remind you that Jake Lloyd is the kid who played Anakin Skywalker in Star Wars: Episode I - The Phantom Menace. If I recall correctly, Mr. Card was relieved to discover the high quality of child acting, because it meant that he wouldn't have to dumb down the story quite so much. I'm almost certain I heard that Peter and Valentine would be dropped entirely. I cannot bear to go on. Finally, the unifying theme between HTTP Server and Orson Scott Card is that, some time ago, Mr. Card attempted to co-author a novel with the Internet. Does anyone have a link for that?

27 October 2005

Ross Burton: Posture

Recently I've started to suffer from using a laptop as my primary work machine, namely stiff neck, sore back, etc. So I went shopping and purchased a PS/2 to USB cable, and an iCurve. I did toy with other laptop stands but they were either expensive, or incredibly ugly (think huge sheets of grey steel). The iCurve on the other hand is invisible... My Desk Here my unsed desktop's mouse and keyboard are plugged into the USB dongle, which through the magic of the kernel 2.6 input layer Just Works without any action at all. When I want to use the desktop -- a monthly event generally -- I can just whip the USB adaptor from the laptop and plug it into the desktop. Then I can watch Windows XP fail miserably to handle hardware changing between reboots. It appears that although Windows managed to handle the keyboard moving from PS/2 to USB, it refused to acknowledge that the mouse wasn't plugged into the PS/2 port still.. I had to figure out the keyboard navigation for the login screen and then remove/insert the mouse again. Not a great pain, but I bet that will catch out some normal users. Anyway, the iCurve totally rocks and is a great example of design via simplicity: it's just a curved piece of plastic but the laptop sits firmly on it. I recommend it to everyone who uses a laptop all day.

MJ Ray: Dear West Norfolk Council,

There are three ways in which your new web site is worse than the previous site :- 1. it is hard to read. It doesn't set a background colour (which is good because my browser preferences are my preferred colours), but it sets black text, which is hard to read on my preferred background. This means the site is not following the Web Content Accessibility Guidelines. 2. All of my links and bookmarks for pages on the council web site have been broken. This is very irritating. I will delete most of the links rather than try to find the pages' new homes. Why have you not followed the advice of Tim Berners-Lee (1996, URI Axioms) and other web experts (for example, Jakob Nielsen's Alertbox for June 14, 1998: Fighting Linkrot) and set up redirects? 3. When browsing the site, I sometimes get an ASP.Net error page with a stack trace telling me that I haven't got permission to use the site. If I wait a minute and reload the page, it usually appears. What is the problem and why aren't you using customised error pages? It looks like the site could be quite an improvement, but it currently doesn't get the basics right for us old visitors. Also, why is this comment textbox so small? It's barely 10 letters wide for me. I await your reply with interest. MJR Postscript for blog only: I didn't even start on the more general problems with the navigation, attempts to make page links look like adverts, abuse of query strings, or all other others. I think the site is still an improvement, especially if you use View->Page Style->No Style.

Joey Hess: thread patterns

Here's how to subscribe to mailing lists with a combined total posts of 2000 or more per day, and live. It's all about pattern recognition. Threaded mail readers such as mutt sort emails into a tree based on which emails are replies to other emails. The mail index displays this tree of messages with the author of each indicated. Since the Subject field rarely changes, mutt does not display it unless the thread's subject changes. Combining these elements of author names, thread trees, and occasional subject changes produces patterns that the brain can use to quickly identify important and useless sets of mail messages, without actually reading anything, and without resorting to complicated and fragile killfile and scoring systems. Some patterns are very simple. For example, this is the "take it to private email" pattern. This pattern can be thread-killed on sight; if you're feeling generous, read the last two messages in the thread.
bob    +-> Foo
fred     +->
bob        +->
fred         +->
bob            +->
fred             +->
bob                +->
fred                 +->
bob                    +->
fred                     +->
This is the "think before you post" pattern.
bob    +-> Foo
bob      +->
This is the "blindingly obvious answer" pattern. If you're bored you can read any one message to get the gist. Sometimes many of the replies will be worth reading to get a broad overview of all possible responses to a given obvious question. Most times not.
bob    +-> Foo?
fred     +->
alice    +->
george   +->
nancy    +->
steven   +->
nick     +->
Here's a deceptively simple pattern, the "uninteresting message". It might be worth checking the post date to make sure that it's not just the beginning of one of the above patterns of course. And if you're feeling generous, you can read some small fraction of them.
bob    +-> Foo?
This might be a worthwhile thread. Notably because it's short, has a reasonable mix of participants, and seems to come to some kind of conclusion.
bob    +-> Foo
fred     +->
alice      +->
bob          +->
george         +->
bob              +->
nancy    +->
fred       +->
And here's a transformation of that same thread featuring "too late for the party syndrome"
bob    +-> Foo
fred     +->
alice      +->
bill       +->
bob          +->
george         +->
bill             +->
bill         +->
nancy    +->
fred       +->
bill         +->
bill       +->
bill     +->
This is a perfect time to er, threadkill bill. Or if feeling generous, read the second or third of his many replies to see what's got him so worked up. To see more sophisticated patterns, you need to categorise participants of the mailing list. A few people almost always manage to turn even a useless thread into something interesting, or have viewpoints that are good foils for your own. Learn to recognise the names of these interesting posters without thinking about it (I'll name them in uppercase below). Similarly, some people never contribute anything useful, and can be filed under the label of k00k. If there are more k00ks than interesting posters it's probably time to leave the list. Most people won't fit in either category. Some people change category depending on the subject. Here's the same potentially worthwhile thread as before, but now the people matter.
bob    +-> Foo
fred     +->
k00k       +->
bob          +->
george         +->
bob              +->
NANCY    +->
fred       +->
Suddenly, three messages of the thread become worth reading, and the larger k00k-tainted subthread's likelyhood of being valuable drops substantially. Similarly, this thread can be ignored.
k00k   +-> Foo
bob      +->
fred       +->
k00k         +->
alice  +->
k00k     +->
And this thread has a high potential for being interesting.
bob    +-> Foo
fred     +->
bob        +->
NORRIS       +->
george         +->
bob              +->
NANCY    +->
fred       +->
This thread, a variation of "take it to private email", increases bob's chances of being a k00k. Or he's really right and everyone else is wrong.
alice  +-> Foo
fred     +->
bob        +->
nancy        +->
bob            +->
alice            +->
bob                +->
fred                 +->
bob                    +->
fred                     +->
bob                        +->
This thread is a hard case to call, it depends on how good the interesting poster is in deflecting k00kitude. There could be as many as three worthwhile messages in here; I'll flag them.
  k00k   +-> Foo
  bob      +->
* NANCY      +->
  k00k         +->
* bob          +->
* NANCY          +->
It might be worth reading the interesting poster here, but probably only for a laugh, and it's just as likely that they've been cruelly trolled into answering, especially if an instance of the "blindingly obvious answer" pattern is grafted onto one of the subthreads.
k00k   +-> Foo
NORRIS   +->
k00k       +->
NORRIS       +->
So far the Subject has been ignored, and generally it's more important to look at the thread structure than the subject, but there are useful exceptions. It might be worth checking out the differently named subthread here, on the other hand its close proximity to the k00k likely means its a useless tangent.
bob    +-> Foo
fred     +->
k00k       +->
bob          +->
george         +-> Bar (was: Foo)
bob              +->
fred               +->
fred           +->
tony     +->
fred       +->
Here is not just one thread, but a collection of threads. This pattern, typically associated with a much larger thread than shown here, is a sure sign that a thread has gone pear-shaped and unless the followup thread has a lot of interesting posters in it, there's not much hope for the lot. (k00ks also spawn disconnected threadlets; such threadlets should be ignored.)
 k00k   +-> Foo
 bob      +->
 NANCY      +->
 k00k         +->
 bob          +->
 NANCY          +->
 bob    +-> About foo..
 tony     +->
 k00k       +->
 alice  +-> That foo thing
That's enough patterns to get started with, but they really come into their own when picked out of larger threads in an overloy long ongoing discussion. A few examples can be found in this segment of 23 lines of a much longer thread.
bob                                                       
k00k                                                      
tony                                                      
k00k                                                      
tony                                                      
k00k                                                    +-
bob                                                  
k00k                                                +-> Bar
john                                    +-> Bar
nick                                  +-> Bar
barney                                  +->
nick                                      +->
nancy                                       +->
NORRIS                                        +->
nancy                                           +->
SAM                                           +->
nick                                            +->
NORRIS                                            +->
oliver                                          +->
john                                    +->
frank                                     +->
john                                        +->
tom                                           +-> Mumble
bob                                             +->
Part of this thread is useless by two criteria; it has far too much k00k in it, and it's nested so deep that mutt doesn't bother to try to draw the thread indicators. The next bit though shows some signs of being interesting despite its fairly deep nesting. And the tangent might be worth keeping an eye on. Those are the thread patterns that I know I know. I suspect there are many others that I also know, since I can typically read mail with the d key as fast as mutt will scroll, stop at the interesting spots, and not miss much. If you know of other patterns, send them my way. Finally, even if you prefer to read every post, please do us all a favour, imagine your reply is already in the thread structure, and look for patterns like "take it to private email", "blindingly obvious answer", "too late for the party syndrome", and k00k influenced posts.

26 October 2005

Andrew Pollock: [tech] New toys

We've been stocking up on gadgets for our upcoming trips. Camera Sarah's going to Singapore to catch up with some relatives and then joining me in the US a week or so later. As our digital camera is currently a 1 megapixel afterthought on our Sony DCR-PC100E Handycam of 5 and a bit years, we thought it high time we got something half-decent as a compact camera. I'm moderately keen on getting a digital SLR, and after using Mikal's Canon EOS 350D when we went to San Francisco for our Google interviews, wouldn't mind getting one of those down the track and doing a photography course. So we tossed up whether or not to get a compact now and an SLR later, or scrap the SLR, and get something in the middle like a Canon PowerShot S2 IS. We settled on getting a Nikon CoolPix 5900, partly because apparently all the PowerShots are stuck in Customs at the moment and there's none to be had in the country for love or money. iPaq and GPS There is no way I was going to drive in the US again without some form of satellite navigation in the car. There's just too much going on on the roads over there (not to mention driving on the other side of the road) to have to worry about how to get from A to B. We were just intending to buy a car that had satellite navigation when we got over there, and try our level best to get a hire car with one in the interim. Some friends were saying that we'd probably pay a lot more for a car with it as a built in option, than if we were to buy a handheld/portable GPS. Then Mikal bought a bluetooth GPS for his iPaq, and that convinced me to go that way as well. So I bought an iPaq hx2100, which interestingly seems to have just fallen off HP's website (it was there on the weekend), so it must be approaching obsolescence or something. Today I got the Destinator software with maps for the US, and some evaluation maps for Australia, and tonight Sarah and I went for a spin to try it out. It was pretty cool. One thing that could be better is the differentiation between the directions leading up to a turn and turn itself. For example, it says "Turn right in 300 metres" and then proceeds to count down (e.g. "Turn right in 100 metres". Then it just says "Turn right". It'd be more obvious if you didn't have to listen for whether it was "in x metres" or not and either tacked "now" on the start or end of the final direction. It was also cute how it called roundabouts "circles". Going straight through a typical roundabout was "Take the second exit on the circle". If you ignored directions at some point, it'd plot a new route to still get you to your destination. All in all, I'm pretty happy with that purchase. The bluetooth GPS unit itself is cool. I'm able to talk to it from our PowerBook under MacOS X as a bluetooth serial port, and I'm yet to try the same with Linux on my D610. Hopefully I'll be able to get it work with gpsdrive The one downside with getting an iPaq and running Pocket PC 2003 (or WinCE as I prefer to call it) is it's forcing me to spend more time in Windows on my laptop than I otherwise would, just so I can do syncs and stuff. Hopefully once I've got the iPaq all bedded down, that'll change...

Axel Beckert: Supporting Free Software via vendors

Steve wrote in his blog:
I’ve seen this argument before “Buy distribution of GNU/Linux and support free software programmers”. The only problem I have with it is that it is incorrect. Buying GNU/Linux distributions helps the vendors who created it, certainly, and may indirectly help pay for some free software in the sense that the vendors might ship free software they wrote (e.g. SuSEs Yast 2]). However plonking down real cash-money for a boxed set of SuSE gives no money to the people who created MySQL, no money to the people who created Firefox, no money to the people who created Emacs, Vim, Bash, and Catan/Pioneers, etc.
I think, in general you’re right. And if you — as you did :-) — take SuSE, it usually works. And you’re probably also right for most people who just know the big, commercial distributions. But what if you take a free distribution like Debian or some of the BSDs, e.g. OpenBSD? How much truth is in there then? Especially in the case of OpenBSD your view doesn’t seem work, because if you buy an (official) OpenBSD box, you pay the developers — or at least a few of them — of the operating system core and some mission-critical applications. But what if you take community based distributions like Debian? You distinguished between distributor and authors of free software. In my eyes especially Debian, but also some other community based distributions are both at same time. So IMHO you can put them on the author side of your view. And since many Debian vendors (at least those I saw) donate a part of the profit they make from selling Debian CDs or DVD to the Debian Project. Or they offer additional shopping cart items “Donation to Debian” if you order a Debian item. (Example: LinISO.de) Another question in this context would be, how the FOSS world would look like if there are or were no commercial distributors. It probably would be much smaller because some marketing and some lobbying would be missing. Although that’s the only implication which comes to my mind, I’m sure, there are many more possible views on this subject. But as I said, IMHO you’re right for most cases.

25 October 2005

Steve Kemp: Building & Searching

buildd
Thanks to some useful feedback to people who read my request I now have a working buildd setup. Wouter pointed to Debian’s own documents on the subject which were certainly useful. However they are not sufficiently useful. For example it’s simple enough to understand from reading the supplied recipe how to setup a buildd. This will let you run something like:
sbuild -d stable -v screen_4.0.2-4.1
Or
sbuild -d unstable -v screen_4.0.2-4.1
However this is a far cry from a useful tool. What I wanted was a system to which I could upload a package and have it magically be built …
Searching
The Planet search will now correctly honour a server’s /robots.txt file if present. So if your own blog-server contains a robots.txt file forbidding spidering, caching, or archiving then this will not take place - despite the fact that Planet Debian doesn’t contain such a file. Note that several fine blogging systems will respond to /robots.txt with error pages, such as Blosxom which gives this delightful page in response to a request:
Error: I’m afraid this is the first I’ve heard of a “txt” flavoured Blosxom. Try dropping the “/+txt” bit from the end of the URL.

24 October 2005

Erich Schubert: Wireless and Linux

Christopher Aillon mentioned that people like NetworkManager a lot. While I agree that NetworkManager is something nice, and especially people really expect "Desktop Linux" to have it, there are a lot of other issues. I've tried netapplet, which is I think a predecessor. It looks just as fancy, but it doesn't really solve my needs. And in fact, I don't think NetworkManager can do that either (yet?). As usual, it's a bit more than just picking the right essid and maybe displaying the network strength (which doesn't work in netapplet for me, the hostap driver lists a quality of 0 for all networks, but the signal level value is fine), but also a lot about setting up VPN, encryption, handling network switches gracefully - and last but not least: saving power by disabling wireless when not needed. Also it didn't give me a proper list of networks. It just picked a random one (interestingly not the strongest, actually one I don't see right now...) and never showed the other 5 access points. That doesn't mean of course that NetworkDaemon wouldn't, it's just not in Debian yet, so I didn't try it yet. Guessnet is a nice tool for detecting your network setup. Using mii-tool it can detect whether my network cable is plugged in, and by doing "ifup eth0 ifup wlan0" I can bring up whatever is available. Well, almost except that guessnet also fails to detect my wireless networks (it probably would just need to wait a second for the scan to run). I agree that this is mostly an issue of the wireless driver. But just about every driver has it's own issues, unfortunately. For example, the vanilla orinoco driver doesn't do scanning. The hostap driver doesn't properly power down (right now I'm using some iwpriv hack to disable radio tx to save some power), the ralink driver has been locking up the laptop every now and then... some drivers don't do WEP, others don't to WPA. The wireless keyboard shortcut obviously didn't work either... So maybe, we right now (once more) need more people working on the drivers. Oh, and there are more issues with drivers - for example Scorched3D still doesn't work properly on radeon. The OSS nvidia drivers still don't have 3D. Some bluetooth headsets don't work yet... and the closed source drivers are even worse (a pain to install since they aren't properly integrated in the distributions etc.). So Linux still needs more support by hardware vendors (especially WRT to specs!) as well as more people actually doing the dirty job in C and not just having fun with PHP, Python and Mono.

23 October 2005

Erich Schubert: Galeon to become epiphany-based

This Gnomedesktop posting outlines the future of galeon. All it's users (and maybe former users, too) should read it... Basically: the main (current) galeon authors don't have enough time to work on galeon (e.g. on the bookmarks editor, which has some issues). Epiphany, which was forked off Galeon, has a much more active developer community, a more up-to-date codebase, including an extension system. So the galeon authors decided to try to work galeon into epiphany extensions as far as possible (btw, epiphany is to get hierarchical bookmarks independently, so one of the big issues many people have with it is gone then) and maybe make a new Galeon based upon Epiphany to add these features which are not possible with Epiphanys' extension system. Neither Galeon nor Epiphany currently have an easy standing. For example Ubuntu prefers Firefox to Epiphany (albeit Epiphany is way better intergrated in the desktop). This is a pity, since IMHO firefox suffers from featurits. Also I'm not a fan of extension systems like in epiphany and firefox. Especially with firefox, the code quality of extensions varies a lot. And even extensions that are really useful (e.g. the webdeveloper toolbar, albeit it offers little more than I do in Galeon with Bookmarklets) still suffer from some old bugs (e.g. the "show divs" menu item will still be checked after you changed the page) that are maybe just not fixeable in the extension. At the same time, using extensions basically means that the application will be (and behave) different on the machines you work on, unless you spend a lot of time in installing the same extensions everywhere (and then in turn syncing their configurations as well etc.). Neither will the UI be consistent, themes won't support the extensions etc.

Baruch Even: The making of a Planet

Planets are a fairly common method to aggregate blogs. They are especially pervasive in the FOSS world, with planets for Debian, Gnome, KDE, and many others. I find planets as a useful resource for a community to give a single place for the communication and to check for updates. The usual method of communication in blogs is a reply in a post, the planet makes the replies come in the same page for the reader with little context loss. For this reason I'm also fond of setting up planets myself for those communities that lack them, and so I setup planets for FOSS-IL for Israeli blogs about FOSS issues (mostly in Hebrew), Planet (former) Advogato for former Advogato bloggers and the latest one is Planet MicroISV for MicroISVs. I was asked to provide some (tutorial help something) on setting up a planet, and this post is the answer to that request.
The PlanetPlanet program is a very common RSS feed aggregator, it works with most feeds and is fairly tolerant to non-standard-conforming feeds. It is also relatively low maintenance, which is why I chose it for my aggregators. Prerequisites The first thing you'll need is to make sure you have Python 2.2 or better installed. If you're on a sane OS, you can just do apt-get install python2.3 otherwise you are left to fend for yourself. For the Windows folks there is ActivePython. Another would be prerequisite is GNU Arch or GNU Arch or Bazaar, two implementations for the Distributed Revision Control algorithm which was pioneered in GNU Arch. Bazaar would be more user friendly, but both IMNSHO are horrendous user-interface wise. Which is why I provide a snapshot of the latest revision for your benefit. Install Installation would be fairly simple, just unpack the tar.gz and it's installed, nothing else needs to be done, except configuring it. The snapshot I provided is just a raw dump of the arch repository, it is useful as is since you can update the installation as needed by just updating and merging with Arch/Bazaar. This will not be covered here. Too much of a trouble for now, and the PlanetPlanet development is at the pace of a snail carrying an elephant, don't expect updates in the near future. Configure I assume you have in mind the list of blogs you want to put on the planet. It need not be comprehensive, a few blogs to start would be good enough. It's trivial to add more as you go. In the planet directory you should copy the examples directory to a new one, say myplanet, copy the output directory to myplanet-output and edit the myplanet/config.ini file. At the minimum you should change the following variables: The next stage would be to replace the existing blog listed in the config.ini file with your own list. The example is there and is trivial to follow, the entry for a blog looks like:
[http://baruch.ev-en.org/blog/index.rss2]
name = Baruch Even
Where the feed URL is in square brackets and the name of the blog is the name. There are various games that are possible with the templates but we'll ignore them for now and let you learn them from the examples provided by the authors. The next stage is just to run the planet on the new files, we will use the defaults for the rest.
python planet.py myplanet/config.ini
The planet will work for a while, churn out various uninteresting messages and generate the files we asked it for in the myplanet-output. You can now inspect the files in the output directory, load them in a browser and enjoy. Tweaks So you haven't left yet? Want some more info? One obvious question is now that we have the files, how do we serve them to the world so everyone can enjoy our creation? First, you should ask yourself if the world really cares... you do, ah?! OK. If the world cares enough it will find a way to show you how to do it. Since it depends on your OS, web server and various configurations, I can't help you on this. This is left as an exercise to the reader. The configuration in config.ini should be fairly obvious and is well commented. The look of the site depends on two factors, the HTML that is generated, which is a clean HTML version 4.01 and has all formatting controlled by the CSS file which was kindly provided in the outputs directory. The templating code is very simple, it has two operations, TMPL_LOOP and TMPL_VAR. TMPL_LOOP will loop over a variable, usually the Channels variable. And the TMPL_VAR operator will emit that variable, there are the global vars and the loop vars. The best way to figure it out is to use the existing templates as a building block, they are fairly easy to understand. Enjoy your new Planet!

22 October 2005

Andreas Rottmann: Scheme48 fork update

Mike Sperber finally reviewed my patches; they unfortunatly were not deemed appropriate for the Scheme48 distribution, see this thread. Hopefully these issues can be sorted out in the not-to-far future. If you also need the one or other features from my hacks so far, and are adventurous, you can conact me on #scheme on freenode for help with getting and building my fork. Writing portable Scheme programs with scmxlate and spells For the conjure project, we are using scmxlate to make it portable across multiple Schemes. For that purpose, I slightly extended scmxlate and built a kind of meta-module system on top of it. Here is how that looks like: You write a description of the modules your application or library is made of; this is done in a sightly extended subset of the Scheme48 configuration language. For example (from this page, see there for more details):
 (define-structure conjure.foo.bar (export qux baz
					  ((froboz fribnitz)
					  :syntax))
  (open scheme srfi-1 srfi-13 conjure.util.files)
  (dialect (guile (open ice-9.syncase))
           (scheme48 (open extended-ports)))
  (files (foo basic-bar)
         (foo bar)))
This defines the module conjure.foo.bar, which exports the identifiers qux and baz, as well as the macros froboz and fribnitz. The open clause means: this module is written in R5RS Scheme (scheme), plus additionally using srfi-1, srfi-13 and the conjure.util.files module. The dialect clause can be used for specifiying additional modules needed for the dialect-specific code for the module. Finally, the files clause tells us that this module consists of the files foo/basic-bar.scm and foo/bar.scm. This file then gets processed by scmxlate, generating a file with the right module definitions for the selected target dialect, e.g.:
(define-module (conjure foo bar)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-13)
  #:use-module (conjure util files)
  #:use-module (ice-9 syncase)
	
   #:export (qux baz)
  #:export-syntax (froboz fribnitz))
	
 ;; code for foo/basic-bar.scm and foo/bar.scm follows
will be generated for Guile. We recently split scmxlate and the meta-module systeem out of conjure, see the scmxlate category in the conjure archive, so it is available for other projects. Now the split-out of the general purpose modules into a separate project — SPELLS, (S)pell’s a (P)ortability (E)nvironment (L)ibrary for (L)ots of (S)chemes — is in preparation. This library will further aid writing portable code, by providing a consistent interface to functionality that has different APIs in different Schemes. These modules are already there: All of those are implemented for all of mzscheme, Guile, Scheme48 and Gauche, using native functionality where available. Other modules will surely follow, a project has been requested at Gna! to facilitate contribution. The spells library will also be used by my upcoming port of G-Wrap to Scheme48.

Andreas Rottmann: Some thoughts on binding C and Scheme

This are some random thoughts I posted to the G-Wrap development mailing list regarding creating bindings for C libraries for Scheme. Although partly G-Wrap specific, it also might be of interest to other Scheme hackers. I’m not at all convinced my effort to make G-Wrap support Scheme 48
makes much sense at all, for these reasons: So in short: G-Wrap’s future looks brightest when staying a Guile
(-only) tool; a much more simple, portable C-binding tool can be
achieved by:

Andreas Rottmann: A Guile rant

I began to program in Scheme using the Guile interpreter. While I knew that its not blazingly fast, its the official GNU extension language, and as feeling quite close to the goals of the GNU project and the FSF, I felt confident it was the right choice, also considering the supreme quality of other GNU software, such as the GNU toolchain (GCC, binutils, gas) and the Gimp, to name just a few. So, feeling confident with my choice, I started to crank out code and eventually even took over maintainership over a Guile application, namely G-Wrap, after giving it a complete brush-up code-wise. When Tom Lord, of GNU Arch fame (and coincidently a former Guile maintainer), announced the Pika project (a from-scratch Scheme implementation, with ambitous goals), I decided to get on the mailing list and lurk, and later got opportunities to contribute a bit. Unfortunatly that project stalled due to time constraints on Tom’s side. Anyway it was a very valuable experience, as it opened my eyes to other Scheme implementations, foremost Scheme 48. Looking at its code base was a real eye-opener: as opposed to Guile, it was, except for a tiny amount of glue code, written in Scheme; its virtual machine is written in a subset of Scheme called Pre-Scheme that can be compiled to efficient C code, so you get most of the benefits of Scheme and the speed of C. Around the same time I discovered Scheme 48, I got involved in conjure, a make replacement being written in portable Scheme. I split off the library code from it to form a separate project, spells. As spells is basically a layer above the individual Scheme implementations which hides away their differences and presents their features (foremost the module system, but also hash tables, file system access, …) in a portable way, I gained some experience regarding the different module systems and how they compare, and I honstly must say that Guile’s is basically unusable with macros. Here’s why: A decent module system allows for macro code to refer to bindings in the module they are defined in, without requiring these bindings to be also exported; imagine a macro that expands to a call to some helper procedure that should itself should not be visible from outside the module. A real-life example are the reference implementations of SRFI-34 and SRFI-35, which define the helper procedures guard-aux and type-field-alist->condition, respectively. This deficiency (which is not present in Scheme 48, PLT Scheme, Gauche and probably most other Schemes) is really unfortunate, as it makes modules, when used with macros, a lot less usable. This, besides the total orientation toward interpretation and the codebase that is mostly in C are reasons why I’d recommend Scheme newbies also looking at other options before settling on Guile because it’s the “official GNU extension language”, as I did ;) .

21 October 2005

Andreas Rottmann: Some thoughts on binding C and Scheme

This are some random thoughts I posted to the G-Wrap development mailing list regarding creating bindings for C libraries for Scheme. Although partly G-Wrap specific, it also might be of interest to other Scheme hackers. I’m not at all convinced my effort to make G-Wrap support Scheme 48
makes much sense at all, for these reasons: So in short: G-Wrap’s future looks brightest when staying a Guile
(-only) tool; a much more simple, portable C-binding tool can be
achieved by:

Zak B. Elep: Any Linux users in Naga City?

Hey guys and gals, are any of you in Naga City? I’ll be there tomorrow to take my natsci final exam at USI, and I thought it would be nifty if there are some Linux geeks to meet up with. I hear there are some Fedora users at AdNU; how about Debian dudes or Slackers? =) If any want to meet up, just text me at 0915-5380648. =)

Joe Wreschnig: Vorbis comments and tracktotal

Breaking radio silence to complain about something both trivial and technical, so it’s probably best if everyone skips this post. Unless you write a CD ripper or audio tagger. Then please read this post, because I’m going to explain why you’re wrong. (Someone emailed me about why Quod Libet acts this way, and I figured I’d make my answer public, with the hope it helps things.) History
Decades ago, before there was Ogg Vorbis, people used an obsolete standard called MP3, and tagged it with something called ID3 (in particular, ID3v2). One of the possible tags was TRCK, for the track number. It was stored as a string in “x/y” format, for track number x out of y total tracks. Perhaps this could be improved upon; maybe not (I’ll make a case for not later). Regardless, that’s how hundreds of thousands, if not millions, of files were tagged. Ogg Vorbis Comments
These days we have something better — Ogg Vorbis and its tagging format. Vorbis specified a tag called tracknumber, analogous to TRCK.
TRACKNUMBER: The track number of this piece if part of a specific larger collection or album
Now, this is a bit ambiguous. In particular, TRCK says how you should store the total number of tracks, and the Vorbis comment specification doesn’t. A strict reading indicates you can’t, but then the same standard is designed to be particularly loose about the data stored in the tags. So a lot of programs, including really popular ones, just kept their ID3 format and wrote tracknumber=x/y. Everyone was happy. Then someone — I wish I knew who, so I could write this to them personally — decided trying to parse the track number in this format was too hard, and so decided they would make a tracktotal tag that stored, as a single number, the number of tracks. Whoever Did This Is Wrong
Whoever decided to do this was pretty dumb. There’s a number of false assumptions here, roughly in decreasing order of annoyance: The result is that every program still needs to understand x/y — even if every Vorbis file used the new format — and the new format, and also needs to do the work to construct track numbers in the new format, assuming it wants to use them. That’s why Quod Libet converts everything to x/y format. I urge authors of tagging applications and CD rippers to abandon stupid standards. Instead, you should be spending time fixing your ID3v2 readers and writers, because they all suck too. P.S.
If anyone knows what program is putting ISO-8859-1 values into Vorbis tags, please let me know. I have spiked cluebat for you. A Summary of Other Things
I moved into a new apartment building next door to my old one, owned by the same student co-op, so it doesn’t actually seem like I moved at all. School started and is going well. I saw DOOM earlier this week for free, and enjoyed it. I’ve learned a lot about Python i18n over the past few months and am writing a brief howto explaining how to do it properly.

19 October 2005

Scott James Remnant: Parallel Peer Programming

Here at Canonical Towers we have several staff who worship at the altar of Extreme Programming, and as such many of the methodologies and rituals prescribed by that religion find their way into our day-to-day working practices. A few of these came together in an interesting way a few weeks ago, and it was suggested by a cow-orker that I blog about it so he could give the URL to people. The first ritual is that of the sprint, I don’t think this is orthodox XP but rather something inspired from it that we picked up from the Python community. With all of the Canonical developers scattered across the globe mostly working from their own homes, it’s become a useful tool; particularly for the Launchpad team. The basic idea for those that haven’t heard of it is simple, and perhaps obvious; you get a selection of the team together in one place, sit them around the same table with particular goals to complete. In effect it’s highly compressed facetime and high bandwidth interaction to nail those tasks that need it, before you head off again and work at a more sedate pace. The second is directly from XP doctrine and is that peculiar observance known as pair programming, something that is often coupled with sprints. For anybody who hasn’t encountered this before, it’s something I’ve always found rather odd. You get two programmers together, both itching to code, and you take one of them’s laptop away; and you don’t just force them to fight over the keyboard either, the laptop-less soul isn’t allowed to touch it. The theory here is that it frees the deprived individual of the hassle of coding and allows them to direct the programmer in ways that may not be immediately obbious, or alternately think about the next bit of work that needs doing. Another interesting side-effect is it can be an interesting way to learn code you’ve not worked with before, if you’re the one doing the coding and you’re being guided what to do by a sage who already knows it. I have a funny story here, so I’m going to digress from the main stream for a moment to tell it. A few months ago I was working in the London office, Mark had been up all night coding and had then given me responsibility to get his changes landed onto the Launchpad mainline. I’m not that hot on quite a bit of Launchpad, and fade to utterly clueless the nearer the code gets to the web application itself; and when trying to merge the two there were conflicts which I needed Mark’s help to resolve. Now as anybody who’s met Mark knows, he’s a pretty good example of a Type-A personality, yet he suggested that we do a spot of pair programming to get the code in and I’d be the one with the laptop as it’d help me get to grips with the affected parts. This hilighted something I’ve always seen as a problem with pair programming, dealing with it when the a person with the keyboard has a totally different way of working to you. In particular, I’m an emacs user, whereas Mark is a die-hard vim user; but also right down to the working directory I would work from, how I test results, etc. When you’re the one without the laptop, this can be quite infuriating, as you know exactly how to solve a problem and the idiot with the keyboard is dithering about doing things you don’t understand just to get there. If you’re a Type-A personality, you generally snatch the laptop away at this point and do it yourself; or at least you would, if you could drive the strange editor the other person uses. I swear Mark was sulking as he gave the laptop back and let me do it. Anyway, there is some relevance to that and we’ll come to it in a moment. The third and final methodology is the concept of unit tests and more specifically test driven development. For anyone who hasn’t come across this before, I highly recommend it; I was suspicious too when Robert Collins took it upon himself to teach me the true way, but now I’m sold. Simply the idea is that if you have any code that doesn’t have another piece of code in a test suite that checks that it’s working correctly, that code is broken. More particularly unit testing involves checking just one feature or requirement at a time, and stacking them together to test all of the code paths. I’ve actually found that this improves the APIs I design, as I write the code in small blocks and functions to make them easier to test. Test driven development takes it even further, you write the unit tests first, before you write the code they’re supposed to test; usually one or two at a time. Obviously these tests will fail at first, it’s then your job to write as little code as possible to make them pass. If your code isn’t right, you add a unit test that will fail, and modify the code to make it pass. This really comes into its own when you’re fixing bugs later, once you’ve identified the bug you write a test case or two that cause the problem; these will of course fail. You can then modify the code to make them pass, and at the same time be sure you’ve not broken other functionality because of the existing test suite. I’ve also found it really useful for particularly complicated or tricky pieces of code, especially those intricate algorithms that do particularly heavy lifting. So onto the event itself, this was a sprint in our London office to indoctrinate Gustavo Niemeyer with the various projects he’d be working on. The goal for this sprint was decided to start the conversion of HCT to Bazaar-NG, and to do this Gustavo and I would pair program. Now my last experience of pair programming had been that story with Mark (see, it had some relevance) and I knew I’d be just as bad if I wasn’t allowed to have the keyboard. I was also acutely aware that if Gustavo was just sitting by and watching, he wouldn’t get much benefit from it either, so he needed to be actively involved in the coding so he could learn the things he’d be working on. I came to what I thought was a pretty neat, and obvious, solution to these problems. We set up my laptop with the code we’d be working on, and on my display were two side-by-side terminals both running screen sessions. Gustavo then set up two same-sized terminals on his, ssh’d into my laptop from both of them and joined the screen sessions. In the left-hand one he ran vi, and in the right-hand one I ran emacs. Thus we both had keyboards, and both had editors, yet could see each other working and even steal the keyboard without danger of violence. We didn’t just sit side-by-side and code on different things though, that’s not pair programming and is just ordinary programming with a bit of a voyeuristic twist. What we did was: in my terminal I started writing the test cases for the code we needed, it was Gustavo’s job to write the code that would make them pass. We actually added a third terminal in which we could run the test cases themselves; so I could run them when I’d added something that would fail, and Gustavo could run them when he thought he’d made them pass again. This turned out to be a rather fun way to work, and at one point I was almost able to try and convince myself that the code was writing itself to pass the test cases I was writing. It also got me thinking that it’d be really neat to use genetic algorithms to breed code to pass test cases.

18 October 2005

Scott James Remnant: bzrk 0.1

Over the weekend in a stunning example of timing, fabbione showed me a screenshot of gitk, the branch visualisation tool for git that he’s discovered while getting the Ubuntu kernel patches into a branch. He, quite rightly, was upset that we didn’t have anything like this for bzr. Well, we do now: It’s implemented as a bzr plugin, so you simply run “bzr visualise” (or “bzr viz”) in a working tree and the window opens to show you the history. Download here

Next.

Previous.