python -m SimpleHTTPServer

This serves the current directory on port 8000. Avoid that if you’re not firewalled, but on a local machine, that’s really practical for quick testing.

The symptoms

As it appears at random time, and slows down everything, diagnosing is not easy. I usually keep gkrellm open to monitor what’s happening. During these slowdowns, almost everything seems normal: cpu at less than 5%, more than 70% of the memory free, no disk io, no network io. Nothing unusual either with iftop or iotop. The only visible problem in gkrellm and in top was the load average. The load was climbing up (sometimes to 10) before coming down slowly.

Note that I changed the default monitoring string for proc in gkrellm to <code>\w88\a$p\f procs\n\e$u\f users\n\e$l\f load</code> to display the load value.

It would happen on any website, it would happen with chrome or firefox. And I couldn’t find anything relevant to this issue on the internet.

Fixing

The first step was to find a way to replicate this as it seems to happen at random time and on random sites. I finally figured that using chrome or firefox and going to google maps, heavily moving around, zooming in and out, navigating in street view would eventually trigger the problem. At this point I suddenly though about caching issues.

And then I got it.

My /home is on a raid 1 setup: I don’t want to loose all my photos to a hard disk crash (don’t worry, the raid is far from being the only backup of it). But most linux softwares are in the habit of putting all user related stuff in ~/.* and chrome and firefox are no exception. For example chrome keeps its stuff in ~/.config/google-chrome. Writing to the cache is not a cheap write operation and my guess is that is does a lot of random access write. Then the raid system has to sync all this between the disks and that increases the load of the system. It does not appear as disk IO in the different monitoring tools as this is not a filesystem IO.

From there, the fix was pretty simple. Move the ~/.config/google-chrome to a non raid disk (as chrome sync everything to the cloud, loosing the config directory is not an issue) and create a symlink ~/.config/google-chrome to the new location.

Lessons

Several useful lessons to get from that:

• Using /home for cache is bad. The assumption is often that data there are worth saving, mirroring etc and don’t require a fast access.
• There is probably some room for improvement for the linux raid driver: I can’t believe it could be so inefficient for some write pattern. Or I didn’t select the correct options when setting it up.
• I need to find a better monitoring tool for my raid.

Ca donne un univers un peu décalé: au supermarché on peut voir des gens se balader avec un tee-shirt sur lequel il y a quelques lignes en Haskell, et le caissier poser des questions sur le sujet. C’est possible aussi que ce soit précisement le supermarché où les employés d’Apple sont allés acheter le beurrier et les déodorants (les billes!) pour réaliser une des premières souris il y a 30 ans…

Evidemment tous ces geeks, ca pose des problèmes: par exemple, je capte au moins 32 réseaux wifi chez moi avec toutes les interférences que ca pose (et il faut garder en tête qu’il y a très peu de batiments de plus de 2 étages et que la densité est très faible). Tout le monde change de canal de temps en temps pour optimiser sa réception. Ca donne aussi un monde hyperfocalisé sur les dernières nouveautés: la prochaine startup qui va révolutionner le monde, le dernier produit de X, l’achat de Y par Z, l’entrée en bourse de W, avec les loyers qui suivent le cours de la bulle… Le moindre couple d’amis a au moins une moitié dans le hardware ou le software.

Aux US, on peut aussi personnaliser sa plaque d’immatriculation. Du coup, ici on trouve des choses comme “C IN 3D” ou “UID EQ 0″ pour quelques exemples que je croise régulièrement tous les matins. Dommage que ca soit limité à 7 charactères, sinon quelqu’un aurait tenté un “‘;DROP TABLE” pour faire sauter les contraventions.

A part ca, la diversité est impressionante, les gens viennent de partout (bon, ok, beaucoup d’inde et de chine, mais c’est surement proportionnel à la part dans la population mondiale). Dans la moindre équipe de travail, il y a au moins 3 continents représentés, pareil pour la moindre sortie avec des amis (euh ok, juste une sortie en famille et c’est déjà le cas pour moi…). Et même parfois on trouve des américains. L’avantage, c’est que du coup on n’a pas de problème pour trouver des bons restos et des ingrédients à cuisiner (ca contraste avec mon séjour dans “upstate New York” il y a quelques années).

C’est aussi un peu dans le futur, les voitures autonomes sont sur ma route tous les matins, les gens se promènent avec de droles de lunettes et tout le monde teste la dernière nouveauté secrète de sa compagnie respective.

sort -rnk2 -t $'\t'

Basically that’s the answer to the question “How to sort a tsv file in reverse order by the values of the second column?”.

Few days ago, I’ve just realized that emacs has a batch mode: you write your function (leveraging all the existing emacs functions), put it in a file and you can apply it on a bunch of files:

emacs -batch myfile.cc \
-l the-lisp-file.el \
-f the-function

Not necessarily the fastest or the most portable, but if you happen to have the right emacs function around, that’s invaluable. For example, I wouldn’t be too sure how to grep/sed to do this:

(defun apply-style ()
  (c-set-style "stroustrup")
  (indent-region (point-min) (point-max) nil)
  (save-buffer))

The first one is M-x keep-lines that allow to remove all the lines that I don’t care about.

The second one is M-x csv-kill-fields from the csv mode that allow me to remove all the columns I don’t want.

With these (and some variants around), I’m all set for some quick data filtering.

Apparently, or so I discovered recently, a baby requires care all the time. All the time. Even when sleeping peacefully. Just take at the
range of products and you’ll see that this did not escape some astute companies.

The most interesting part (also the most expensive and probably the most useless) is the video component. It comes in two parts:

• a wireless webcam, with some infrared LED to be able to monitor in the dark
• a receiving unit with a screen roughly the size of a post stamp

There is a huge range of products, with options ranging for 300 foot range (my place is not that big), support for 4 room camera simultaneously (don’t have enough rooms), belt clip, touch screen to zoom, waterproof, etc.

However, I was not very happy to go and buy one of these devices for several reasons:

• there is no information about the protocol used for the wireless communication. Given the security record for this kind of device (for examples on how to spy on your neighbor baby, see here and here again), it’s better to assume that all the neighborhood can help you keep an eye on your baby. I’m not very comfortable with that.
• it’s a one use device: you need to monitor the baby for a few months and then, you’re left with something to stuff in a cupboard (for a few years?).
• it does what it was designed to do. And only that.
• and it cost a few hundred dollars.

So I started toying around with the idea of making my own. The basic idea is simple: hook a webcam to an old laptop and stream the video over wifi, then pick the stream on a computer screen, the tv, or whatever you can imagine. I was pretty confident for the second part of the project: once I have the image on the laptop, the rest would be straightforward.

The tricky part is to get to see in the dark: if you need to shine a projector on your newborn to seen if he is sleeping well, that could be disruptive. So I’ve started to do some research on the technology used by these products. They are all using the same principle, few infrared (IR) LED around the webcam so illuminated the scene without being disruptive (the human eye can’t see infrared). So this is active imagery, I needed to find a solution for the receiver (webcam) and for the emitter (IR-illuminator).

Some constraints for the emitter: as I wanted to avoid pluging too many stuff around, it has to be powered by the USB port (5V).

Standard CCD are sensitive to IR and will be able to show it very clearly. The trick is that most webcam have a filter to remove it as most user want to see the same stuff with the webcam than with their eye. Without this filter, most of the vegetation is bright white:

This photo is from the wikipedia page on Infrared photography.

Just to be clear, this has nothing to do with thermal IR, the wavelength of these LED is just above the red color (ended up using 950 nm LED).

Apart from the artistic aspect of it, IR imagery using cheap webcam has two main markets it seems. One is baby monitoring as we’ve already established, the other one is security monitoring (I sure hope that they don’t come with the security flaws we’ve seen above).

In the security camera market, the device are more flexible in the sense that they are made to be combined, adapted to existing systems, etc. Two major problems for me: outputs are usually RCA (great if you want to plug it to a VCR, not if you have an old laptop) and power for the IR illuminators is 12V (usb port deliver 5V). So out are the security devices.

The best option was to build my own illuminator. There are plenty of IR LED available on the web: just combine a few of them, with some resistors, connect it to the USB port and voila! Few questions, though:

• how many LED to use? I started with 3, tried 6 and settled on 12. It seems sufficient to provide some indirect illumination in a dark room
• what resistor to use? I reused some basic rusty electronic skills, but it was great to check all on http://led.linear1.org/led.wiz.
• where to buy the material? The radioshack I tried was hopeless (I just got some wire from there), ebay had plenty of LED sellers (but the quality was dubious), so I settled for SparkFun (no problem at all).

And few wire stripping later, here is the prototype:

The laptop is an 8-years-old Thinkpad T40 (one of the most reliable piece of hardware I’ve seen), the webcam a logitech quickcam (as old as the T40) with the IR filter removed.

The thinkpad is connected to the wireless network (using WPA encryption) and the video streaming is started with:

cvlc -vvv --color v4l:///dev/video0:norm=ntsc:frequency=543250:\
size=320x240:channel=0:adev=/dev/dsp:audio=0 --sout \
'#transcode{vcodec=mp4v,acodec=mpga,vb=500,ab=256,\
venc=ffmpeg{keyint=80,hurry-up,vt=800000}}:\
standard{access=http,mux=ts,dst=10.1.10.14,port=8080}' --ttl 2

On the other computer (which is conveniently placed in the middle of the living room), just open a vlc and open a network stream on

http://10.1.10.14:8080

And you get something like this:

One problem still, there is some buffering issues and the video suffers a delay of a few seconds on the receiving side that increases slowly. I reach 20s delay after one hour. No solution yet apart from restarting vlc on the client side.

So we are done with the basic minimal setup, but there is a lot of room for improvement, limited only by imagination and by the sleepless nights to come.

Last time, I had some problems with gcc 4.4 not being supported, I had to downgrade to 4.3. Sure enough, similar problem this time when trying to compile the SDK:

/usr/local/cuda/include/host_config.h:82:2: error: #error --
unsupported GNU version! gcc 4.5 and up are not supported!

This time, my standard gcc is 4.6… we are two versions back now.

The fix is simple: edit the common.mk files to have

CXX        := g++-4.4 -fPIC
CC         := gcc-4.4 -fPIC
LINK       := g++-4.4 -fPIC
NVCCFLAGS       := --compiler-bindir /usr/bin/gcc-4.4

(note that there are two common.mk to compile the whole SDK).

It’s not only a question of using a different system. I’m happy to adapt to driving on the wrong left side of the road in half of the countries in the world, or (try) to speak a different language, or eat different food (I love that last one!). Even if the fact that this is a different system alone can cause some issues (like the crash of the “Mars Climate Orbiter” due to the failure to use metric units), the main issue is that the system in use here does not make sense.

The metric system has been invented more than 200 years ago and adopted by most countries for a good reason, it makes things easier! If it didn’t, the cost of change (which traumatize at most one generation) would have been enough to prevent most countries to change. Surprisingly enough, the US was among the first countries to sign the meter convention. But the change has been slow to trickle down to people… (133 years so far, that’s more than 5 generations!)

The other day, I was driving down the 101, 3 ¼ miles before the exit I went under a bridge where the height limit was 14 feet and 4 inches, then I stopped in the supermarket (300 feet after the exit) to buy ½ gallon of milk as I needed 2 cups for a recipe (how many cups in a gallon anybody?), 8 oz of orange juice and a one pound steak (or was it 16 oz?). This obviously doesn’t make sense. And I’m not even going into the issues of combining these units for strength, density, etc… Also note that the cooking cup unit is not the same in UK, USA and Australia (more than 20% different)… that might make it more difficult to translate a cookbook from british to american that from chinese to french (who wants to translate a british cookbook anyway?).

I pity the poor primary school students who have to go through this and I can imagine the endless amount of exercises that this can generate. This would be enough to disgust anybody from science. Could this be a reason for the “US education crisis” mentioned in numerous articles? That would probably not hurt to remove few months spent converting miles to feet to inch or explaining the concept of density (is it in pound per gallon or ounce per fluid ounce here?).

That could be even worst actually, I should feel lucky that the basic time unit is the second at least and not the microfortnight from the FFF system.

One another interesting point is the way to measure the consumption of the cars. In most places is in l/km (litre per kilometer), in the US it’s in mph (miles per gallon). It’s not only the units which are changed, but the ratio is also inverted. Is it coming from a difference in objectives? In most of the places, people want to know how much they will use to go where they need to, but here, people want to know where they can go with what’s left in the car. Or maybe it’s just because here: bigger is better!

One is “Open Source Licensing, Software Freedom and Intellectual Property Law” by L. Rosen. This book is written in the context of US law, but lot of it should be applicable in international contexts. Beyond the basis, I discovered some pretty interesting stuffs. Some are summarized here, but referring to the original book would be good idea.

The first one was the difference between copyright law and contract law. Basically, copyright prevent anybody from making copies of your program, the open source license is the thing that will allow other people to do so. The copyright law is enforceable only by the owner of the copyright. That mean that somebody creating a derivative work won’t be able to enforce the license (as he doesn’t own the copyright). To be able to do so, it must be done under contract law. Thus, a contract must be presented, considered and accepted by the user: click-wrap method (accept button on a website, at the installation, etc) are acceptable.

Few of the most popular licenses (BSD, GPL for example) explicitly mentioned that. Even, the GPL is intended to be applied only as license not a contract.

The possibility of dual licensing is also well explained. I was familiar with the example of Mysql where companies are ready to pay to avoid the obligation of the GPL. But the example of Ghostscript was more unusual: they use the concept of scheduled licensing, where companies pay to have the product one year before the open source version.

Another interesting part of the book is about the open source license with a commercial origin (CPL, OSL and AFL) and particularly their patent defense strategy. The idea is to say “you get a license to use, copy, etc this software, but if you sue us for any patent infringement, this license is revoked”. That work for big corporations with a significant patent portfolio, much less for small open source projects. That’s amazing to see how these big corporation are building an arsenal of patents mostly as a deterrent.

Related to the patent in softwares, the FSF came out with a short movie illustrating the issue: Patent Absurdity. In this movie, one analogy is particularly striking: what would have happened if the patent had been available for music in the 1800s ? As the end of this movie, they illustrate the concept with a Beethoven symphony:

(Note: I sure hope this use of the video come under fair use, as I don’t think it can come under the CC-non derivation as I extracted only part of it. Let’s see if it gets me into trouble with the FSF…)

To come back to the license issue, one question is “what license to use?” Obviously, compatibility with the other softwares you’re planning to work with is an important consideration. The question of compatibility comes both ways: can you use this particular software and can you be used by this software? Of course, I’m not really being precise here: the issue is not really when using the software but redistributing it (but that the whole point of an open source license as they all guaranty that you can use the software with complete freedom anyway).

In most cases, the choice ends up being between an academic license (such as BSD) and a reciprocal license (GPL is one). If the philosophy of the GPL is laudable (every software would end up being shared), it is also very controversial with some even using the misleading term of viral (note: a virus is rarely something you can choose not to get, for a license, you can). On one hand, I wouldn’t want to have my own bugs served me back in a closed source software preventing me to fix them. Also, if somebody uses my work to make a good, fun, useful program, I’d hate not to be able to have a look in the inside to understand how they did it. But on the other hand, the controversy and misunderstanding around the GPL could slow down the progress of an open source project. This point was illustrated by Paul Ramsey on this post: On the road to Damascus… GPL to BSD. The license is not all what matter in an open source project. The community around it is a very important asset and will more efficiently compel people to give back their improvements to avoid the hassle of keeping these improvements in synchronization while the project progress.

Patents and licenses are only part of the issue as the recent problem in ITK with the sparse linear solver highlighted recently. In this particular case, the problem was that some code relied on algorithms copyrighted to the ACM (that’s what happen when you publish a paper in ACM). The ACM copyright precludes uses for commercial purposes. As such, the ACM copyright is incompatible with any open source license (as they all guaranty No Discrimination Against Fields of Endeavor) at least without an explicit permission from the ACM. Apparently, request from ITK to the ACM for the inclusion of these particular algorithms were not successful. At the end, another algorithm was included requiring a translation from Fortran to C++. That’s quite an unfortunate and (from a technical point of view) unnecessary duplication of efforts, wasting resources (i.e. developer time) that could have been better employed (ITK objective is to provide image analysis tools in the medical domain).