L'ardoise eduvax

CTRunner: CPPUnit console test runner.

Sebastien Devaux — Sun, 01 May 2016 21:51:00 +0200

Here is a simple console test runner for CPPUnit I've created to ease running script from make target and display log progression on console using standard log presentation (one line per message: data, thread, severity, message content).

Source code is a single c++ file. To compile this file, use the following command that should run on many linux systems:

g++ -o ctrunner ctrunner.cpp -I<path to cppunit include dir> -L<path to cppunit lib dir> -lcppunit -ldl

Once compiled, run ctrunner directly from your shell, scripts or makefiles:

ctrunner [-x <xml output file>] <test plugin> [<test plugin>]* [+|-f <regex filter>]*

Command arguments :

<test plugin>: path to .so file containing the test suites to run.
-x <xml output file>: paht to xml output file. CTRunner tries to math the JUnit task xml format.
+f <regex>: run only tests having a name that matches the regex.
-f <regex>: run only tests havinf a name that doesn't match the regex.

Tinis - Tiny and simplistic Network Information System

Sebastien Devaux — Mon, 24 Aug 2015 21:26:00 +0200

Tinis is a small script to suppport sharing of some data among few hosts of a small network. It is designed to be as simple as possible to avoid the management overload of the widely used network information systems such as NIS, DNS, LDAP, that are also sometime a bit tricky to setup.

If you have only a reduce set of host that have to share a few data table (typically some parts of /etc files like /etc/passwd for logins), and don't want to setup huge things trying to integrate nss, ldap, NIS or samba, tinis can help you. Tinis is just a script able to patch any file using tag in-closed in comments to insert data from another (remote) file section. It can update a single file or update a file set defined in the only configuration file /etc/tinis.conf.

How to use tinis :

download tinis and copy it in an appropriate location of you file system (personally I choose /sbin) and set executable.
for each file to be patched by tinis, add some tinis tags to define tinis managed sections :

#<< section\_name host:source\_file\_path
#>> section\_name

on the remote host provide source data, define inside each file containing to be shared data the shared section (yes you can share only part of a file) :

#<< section\_name 
... shared data ...
#>> section\_name

trigger a file update :

$ tinis /path/of/file/to/update

trigger a file set (defined in /etc/tinis.conf, one file per line)

$ tinis update

as tinis use scp to fetch remote files containg source data, you may need to share public key across your hosts to grant file copy without password entry.
automate file update : regarding the update policy you want to set up use cron or sysinit scripts to invoke automatically tinis update each time you need.

Example: Here is how to configure your /etc/hosts files to use tinis as a dummy DNS to share IP addresses of 3 host (alpha, beta and gamma), where alpha is the hosts name database master and plop the internal domain name.

alpha:/etc/hosts

127.0.0.1 alpha localhost
#<< plop
192.168.0.1 alpha alpha.plop
192.168.0.2 beta beta.plop
192.168.0.3 gamma gamma.plop
#>> plop

beta:/etc/hosts

127.0.0.1 beta localhost
#<< plop 192.168.0.1:/etc/hosts
#>>

gamma:etc/hosts

127.0.0.1 gamma localhost
#<< plop 192.168.0.1:/etc/hosts
#>>

The Tinis script is free software, feel free to use, modify, and distribute, see GPL V2 for detailed information about granted rights of use.

Repaire a broken nvidia config after debian upgrade

Sebastien Devaux — Sat, 13 Dec 2014 16:26:00 +0100

Sometime, when upgrading your debian linux disto, a new kernal is installed and after reboot, the X server no more starts. This is because, now using a new kernel, the nvidia kernel module is not properly recompiled to fit the new kernel. To solve this you can manually remove and reinstall the related package to force a fresh install that will fit your new kernel.

As usual when configuring and installing system components, log as root. Then just run those two commands:

# aptitude remove nvidia-glx nvidia-kernel-dkms
# aptitude install nvidia-glx nvidia-kernel-dkms

Maybe working with nvidia-kernel-dkms is enough but this way of doing worked fine for me.

For more details about debian and nvidia graphics, visit the debian wiki nvidia page

Update debian in two command lines

Sebastien Devaux — Fri, 12 Dec 2014 16:43:00 +0100

Just open shell as root and enter the two following commands :

# aptitude update
# aptitude upgrade

Re-Synthesized Reality Transportation Game

Sebastien Devaux — Sun, 07 Sep 2014 15:47:00 +0200

How to make long transportation time more fun ? Let's make the transportation itself a game. Using geographic database synthetic world generator coupled with GPS, the traveler may play inside a fantasy world directly derived from the real locations he is going through. All the needed pieces to build such entertainment are already almost freely available: geographic data, portable device integrating GPS and advanced graphics capabilities. Let's try to think about what is feasible by linking all that stuff.

The game concept

A 3D shoot them up game without predefined levels: levels are built live using your location and geographic data. Of course, such game targets the passengers only, The player has no control over the movements of its in game vehicle. It's in game location is driven by its real location according the GPS sensor feed. He can only control an embedded device like a turret to lock and shoot targets. This would result to some kind of Rail Chase game where the track is drawn upon the road you are traveling on.

Other possible variations:

bombing game / vertical scroll shoot them up, more suited for in plane use.
running and avoidance game, for in car or in train use.

Security issues

The game use should push safe behavior of the car driver transporting the players. Then the game shall not become more challenging when the driver breaks the speed limit. It just have to become unplayable. Such system should not be used for building any kind of racing game.

What's need to be done

drive in game position from GPS (quite easy)
build a live synthetic world using geographic data' that is a kind of 3D skinning of geographic data. OpenStreetMap data is freely available for such use and contains many featured object from which game objects may be derived.
setup a cool gameplay by integrating location management with the synthetic world.

More advanced functions and features

record GPS track to replay at home.
exchange cool recorded tracks between users over internet.
multi-player: at home while replaying recorded tracks or live while traveling for the ones that can share a network link (group of travelers in train or bus using wifi, strangers crossing using 3/4G)
more immersion in the re-synthesized world by using other sensors (gyro/accelerometers) to also also integrate a line of sight, not only the location.
improved and advanced accuracy of the re-synthetised world in the case of availability of more accurate and complete data (especially the 3rd dimension and complete buildings' layout) compared to what is freely available from Open Street Map

Anti Visual (Meta) Programming

Sebastien Devaux — Mon, 01 Sep 2014 09:51:00 +0200

More than ten years after the delivery of the first really useable UML software engineering tools, it's time to look backwards and think about the real gains enabled by those tools. It appears that the promises are not yet there and finally many have failed to increase significantly software engineers productivity than just using paper and pen. Most coders are skilled in thinking of classes and writing line of codes, not drawing. But good drawing are really useful, those are only too costly to build and maintain. Then imagine if you can drawing by coding. The same coders that didn't produce any documentation before the availability of doc extractors like doxygen won't no more refuse to present diagrams if their drawing does no more require overwork.

Assumptions

Designing software by drawing and aligning boxes using the mouse and editing properties through forms is not efficient.
Keeping code and diagram synchronized is time consuming and in most practical cases, synchronization is definitely broken as soon as the real implementation starts.
most coders are more skilled at typing text than drawing nice diagrams.
whiteboard, paper and pen remain the best tool to support software engineers brainstorming.

First proposition - reverse the process

Instead of drawing many diagrams and then generate code, why not do just the opposite: write some code and interactively, while entering text, let the tool render automatically some diagrams of the edited code. For most coder, it is quicker to just enter "class MyClass" than drag and drop a class widget, then click, then enter class name... Instead of opening forms when selecting a box on the graphical view, locating the cursor to the textual definition location of the pointed entity is enough to navigate the code and enable the coder to edit the entity’s properties. This of course does not forbid to keep some cool toolbar to have some one click template application features.

Second proposition - a true and complete textual (extended) UML

Think about software as a high dimensional space. Then any UML diagram is in fact a projection of the wide space into a narrower one. Then there is many information loss from the full space to the projected one. The implemented code itself is also a projection with information loss (for instance: think about how to implement aggregation and composition using a language like java or C#, no really visible difference). Then today software engineering remains a very difficult task because it consist in defining a very complex object only through restricted and limited views. And many coders still think only the code view matters.

UML stands for Unified Modeling Language. But in fact, where is the language? We only have some kind of graphical grammar, not so easy to process. Indeed, XMI has been introduced, but it was designed only to support modeling tools interoperability (that is still so limited than finally it is rarely use). It is so hard to read (by human), so don't think about edit XMI files by hand. However a modeling language like what anyone may imagine when thinking about what the language word means in any acronym ending by L letter is a great idea. So why not define one? A real textual language not just only hieroglyphs. Think about why most humans today use alphabets to tell stories in place of some shiny little icons sequences! May be because images is not enough to let people understand each other. Don't be too focus on the learning curve. The most easy to learn tool is rarely the most powerful and efficient. Something like actual UML diagram should be a view and only a view. Such view shall be defined as a query from the high dimensional space :

the list of entity it shall display.
the projection direction, e.g. the diagram type (class, sequence, collaboration, etc)
some rendering options: layout, coloring, filtering some details.

A complete modeling language should be able to describe the whole high dimensional space defining software, not only what is describe by the today known projections:

main entities as UML does: package, classes, relations...
algorithms, processes and equations (are you really able to design any algorithm using sequence or state diagrams?)
threading and synchronization (I simply don't know how to figure threading aspects meaningfully with UML).
documentation (documentation of entities may also be rendered live as the diagrams).
etc: there's surely many missing things that didn't came in my mind while writing this.

It's sad to say we still need another language. Too many people lose time in creating new languages while most of them really need only a good new library of an existing one. Then, if something that looks like what is describe here already exists, please leave a comment. I'd rather like to extend or improve if needed something already there than implementing something completely new.

Third proposition - meta programming

Design patterns are to me the best improvement in the scope of object oriented software engineering of the last years. Then our next generation software engineering shall support design patterns. It shall also support some way of programming automation. Think about how many time you write the same lines of code, specially when applying coding standards and rules: most private class members will need the same getter and setter. Having a collection requires to the enclosing class to have also members to add/remove/check members. Writing all this common stuff can involve more than half the coding effort of a class. Then such definitions should be implemented automatically just by defining some attributes to the class properties that need it.

What is already available

Most of the basic features needed to implement a tool such as the one described above are already available from the eclipse platform and its many plugins:

advanced text editors with automatic completions.
structural model extraction from plain text (or XML) files.
synchronized views
UML drawing

Plantuml is a good example of how to draw diagram by text. It is in fact today my favorite UML drawing tool. It is for me the fastest one. And since it use text file, it is easy to manage under revision control aside the code as any source file. But it remains far away what I dream for:

it is finally a drawing tool only. It is not designed to do anything else even I don't see anything preventing the addition of some cool feature looking like the ones described above.
the syntax is not so convenient. It is quite easy to learn because it tries to match the UML drawing. Going back to real UML concepts should be better.

In the case I can't find any existing relevant base language, prototyping the ideas above will probably make use of my own HEML.

Eduvax projects and sites summary

Sebastien Devaux — Fri, 15 Aug 2014 18:44:00 +0200

JDev - Grant - NaJa - GSP - Records

	Title	Description
	Eduvax Jdev	Free java applications and libraries
	Grant	Grid computing with adaptive and distributed load balancing.
	Naja	a Java like C++ API
	General Server Page	preprocessor that make any lancguage CGI writing as easy than JSP or ASP page.
	Eduvax records	Free home made music recordings (creative commons licence)

Install grub manually to make disk bootable

Sebastien Devaux — Thu, 14 Aug 2014 14:24:00 +0200

Use this procedure to repair a broken boot of a system disk boot or to make a new restored system disk bootable. To run the procedure you need an already running linux. If not available, use a live CD or USB key. The disk to make bootable must already contain a partition with almost complete linux system: in particular drub binaries and /boot directory with kernel and grub configuration.

first ensure what is the partition containing the /boot directory. In the following it's considered to be /dev/sdb1. Check this partition has the bootable flag and add it if not (defaulty use fdisk to proceed).
mount the root partition, and special file system at the right place relatively to the future root partition mount point.

# mount /dev/sdb1 /mnt/
# mount -t proc none /mnt/proc
# mount -o bind /dev /mnt/dev
# mount -t sysfs sys /mnt/sys

start a chrooted shell into the future root file system and install grub from it.

# chroot /mnt/ /bin/bash
# update-grub
# /usr/sbin/grub-install --recheck --no-floppy /dev/sdb

terminate chroot shell and unmount partitions properly and the disk is ready to boot.

Dump and restore full file system

Sebastien Devaux — Wed, 13 Aug 2014 22:57:00 +0200

Tar and other file archiver may miss some specific file attributes and special files. At least for ext2/3/4 file systems, old fashion BSD dump and restore utilities (debian package simply named dump) remains a perfect solution to backup an entire file system. The following procedure may help to move a filesystem from a disk to another.

backup root filesystem to a file. Beware! Avoid to put the backup file on the filesystem to be dumped:

# dump -0z -f /mnt/backup/rootfs.dump.gz

to restore the filesystem, first create a new fresh partition and empty file system (fdisk + mkfs). Then use restore command to unpack the dump file into the new file system.

# cd /mnt/newfs
# restore -f /mnt/backup/rootfs.dump.gz

Mount MTP USB device

Sebastien Devaux — Tue, 12 Aug 2014 13:48:00 +0200

Since mass storage device is not always available, exchange files using MTP becomes mandatory.

1st, install jmtpfs package or simular (mtpfs, go-mtpfs). fuse is needed.
add users that need to mount such device to the fuse group.
create a new directory that will be used as mount point (for instance ~/mtpdev).
For each file exchange session:
- plug your USB device (beware, connection some android phone will fail if in standby mode, unlock your device first).
- mount device: $ jmtpfs ~/mtpdev
- do wathever you want on the mounted file system (unfortunately, much slower than any mass storage device).
- Once all exchanges are completed, unmount file system: $ fuser -u ~/mtpdev
- The device is ready to unplug.

Use an android phone as internet gateway

Sebastien Devaux — Tue, 12 Aug 2014 13:35:00 +0200

Plug through USB the phone to the linux host.

Share the connexion on the phone : go to parameters / More / connexion sharing / USB (may be not exact item labels, my phone runs a french cyanogenmod).

setup the net usb interface on the linux host :

$ modprobe usbnet
$ ifconfig usb0 up
$ dhclient usb0