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).

Of course, some (expensive) solutions exist: SCSI disks, SAS, and now SSD. But before going into that, just standard hard drives and a software raid can increase significantly the output. Using software raid 0 with two disks, you double the output and don’t loose any capacity. Well of course, there is a price, you increase the failure probability: if only one disk fails, that’s it, your data are gone. Don’t use that to store your precious data, just as an additional processing space for data that you can regenerate in case something goes wrong. Don’t use that for the system, don’t use that for /home, etc… Additionally to a heavy processing place, you can also use that for the swap.

The setup is quite easy using mdadm. First, partition the first disk as you need, then copy the partition table to the other disk

sfdisk -d /dev/sde | sfdisk /dev/sdf

Create the software raid:

mdadm -C /dev/md0 -l0 -n2 /dev/sde1 /dev/sdf1

Format it:

mkfs.ext3 /dev/md0

Add the configuration to the mdadm config file:

mdadm --detail --scan >> /etc/mdadm/mdadm.cong

Configure the mounting point in /etc/fstab as if /dev/md0 was a normal partition and that’s it, you’re done.

You should be able to reach 200MB/s effectively with this if you’re using some recent hard drives that are going for less than USD100/TB.

The chapter 8 highlights the fact that science is all about collaboration: first, of course, between scientists (this is more and more the case with the capacity we have to communicate nowadays) but also at the idea level. An idea first get published, then validated by the scientific community and finally accepted. This process has been pretty reliable so far: there have been incomplete ideas that were widely accepted, yes, but any plainly wrong idea that was widely accepted? I can’t think of an example (obscurantism of the Middle Ages aside). One of the condition for this collaboration to flourish is the open access to information: the example of the Philosophical Transactions journal from the Royal Society shows how this idea of open communication of idea was central to the success of Western science.

It is not mentioned in the book but this could well be extended to softwares. Either the software is designed and developed by an expert (or a small group of them), this is the traditional software development process or either the software grows into a more organic fashion that is typically the case for open source softwares. Another advantage is the access to the information on how the software is working and the possibility to adapt it: even if only a small number of the users would ever do that, the leverage is huge. The last advantage is the survival of the fittest: many open source projects start with similar goals and have to compete for the scarce resource that is programmers’ attention. The competition among these projects enable to improve most of them and finally the disappearance of the less fitted to the task.

In the open source world, decisions are usually taken by a group of people rather than imposed. The book also describes the shortcoming of small groups that could, in some conditions, easily switch to some extreme positions and fail to reach an optimal solution. This is an important problem for open source projects that usually gather like-minded people which could prevent the appearance of alternative solution: getting different people on-board is critical.

Another examples that got me thinking is the illustration of the failure of some small groups in the context of space agencies. The author compares the team of the men that managed to save the Apollo XIII mission: “most of those men had worked outside of NASA in many different industries before coming to the agency“, with those at the time of Challenger accident: “NASA employee today are far more likely to have come to the agency directly out of graduate school, which means they are also far less likely to have divergent opinions“. Does that mean that space agencies like NASA, or private companies aiming at particularly difficult tasks should emphasize the diversity of background in their employees?

Install the required packages:

apt-get install bwidget itcl3 itk3 iwidgets4 libtk-img

Follow the instruction in the README_PolSARpro_Install_Linux.pdf file (unzip, run Soft/Compil_PolSARpro_v4_Linux.bat to compile).

Here if you try to run polsarpro, you’ll get an error message (probably depending on which tcl package you have)

version conflict for package "Tcl": have 8.4, need 8.5

To solve that, edit PolSARpro_v4.03.tcl and in the 3rd line, replace ‘wish’ by ‘wish8.5′.

That’s it, should be running now !

The form is a bit surprising. In a book where several of the people being interviewed insist on the importance of details, on a subject for which a misplaced semicolon (think C or Java) or an extra space (think Python) will let the edifice crumble, I couldn’t help but be bothered by the numerous missing spaces after dots, the missing or repeated words, the extra or missing boldface, etc.

Using Tex for the typesetting would have been a good illustration of the last interview (Donald Knuth).

Enough complains… the content is great and inspiring. I never heard of most of these people before (I knew only 3) but it’s great to see these different paths. The lisp community seems to be well represented, is it because every programmer did some lisp in the 60-70′s or because the author himself is part of this community? Anyway, that raised my curiosity and I’ll definitely have a look at it (or some of its children).

Javascript also appear to be worth looking at. The last look I had was around 98 when most of the time was spent making things work well with IE5 and Netscape.

As a direct consequence of this book, I’d borrowed a copy of the first volume of the “Art of computer programming”. Quite eager to start it now… Not sure I’ll practice literate programming, but looking at Tex source code is on my todo list.

There are points where they seem to all agree: the challenge of concurrency programming (most of there worst bugs were this kind) and the fact that the ideal language still has to come.

The interesting part was also in the diversity of opinions:

• on C between those who think pointer was the best invention ever and those thinking that it prevented any further progress in computing
• on Perl where some praise the freedom it gives and other describes its syntax on very striking terms
• on Java whose extensibility is on debate as well as its progress compared to other languages
• even on Lisp, some mention its parenthesis excess

It seems that there is still room for improvement to satisfy everyone! Only on C++ they seem to be quite unanimous (and negative). Bjarne Stroustrup would fit well in the interviewee list to balance this a bit.

The good stuff is that most of them still seem to have fun with what they are doing (and it’s mostly programming related stuff). It appears that the more you learn about the subject, the more windows open up and the part you think you know becomes smaller and smaller… this book definitely opened up many windows for me!

You can produce a very nice matrix like this one. The only problem is that you have to go and actively look for it. As all stuffs that require a conscious effort and are not on the high priority list, this slip away and end up forgotten.

Few weeks ago, I discovered the capabilities of mercurial hooks. So here is the idea: check the style with KWStyle each time the code is pushed to the reference hg repository. We can also check when the code is committed, but that requires each developer to set up the hook.

I just came out with a quick solution using the KWStyle program. It would be much better with some python bindings, but in one hour, I had no time to start building that. Here is the hook:

def kwstyle(ui, repo, **kwargs):
  '''Use it like:

  [hooks]
  commit.kwstyle = python:/path/to/this/file.py:kwstyle
  changegroup.kwstyle = python:/path/to/this/file.py:kwstyle
  '''

  if kwargs.get('parent2'):
      return
  node = kwargs['node']
  ctx = repo[node]
  tempDir = '/tmp/'
  for filename in ctx.files():
    if (fnmatch.fnmatch(filename, '*.cxx')
        or fnmatch.fnmatch(filename, '*.h')
        or fnmatch.fnmatch(filename, '*.txx')):

      fctx = ctx[filename]
      #This would be better handled with python binding for kwstyle
      tempFile = tempDir+filename.split('/')[-1]
      f = open(tempFile,'w')
      f.write(fctx.data())
      f.close()
      cmd = "/home/kwstyle/KWStyle -v -xml /home/kwstyle/OTB.kws.xml " \
        +tempFile
      out = commands.getoutput(cmd)
      message = '*** Checking '+filename \
        +'\n'+'\n'.join(out.split('\n')[1:])
      ui.write(message)
      os.remove(tempFile)

When a new changeset is pushed to the repository, modified files are checked and the result is displayed to the use such as:

*** Checking modifiedFile.cxx
Error #13 (1) The header is incomplete
Error #9 (10) Number of empty lines at the end of files: 2

This is just a quick draft, if it works well, it will be good to have a look at KWStyle python bindings.