The script setting the urgency hint is pretty basic. Here it is:

Set up a DNS server

I must say, that I don’t know exactly anymore, what I did. I believe after installing the named daemon, bind9, I only edited /etc/bind/named.conf.local and added the following:

Then, create /etc/bind/zones/db.SUB.DOMAIN.TLD and insert your desired zone file code, for example:

Replace PC, SUB.DOMAIN.TLD, EMAIL.DOMAIN.TLD, YOUR.SERVER.IP.ADDRESS and YOUR.HOME.IP.ADDRESS with the appropriate values. (The last one is the line we will constantly be updating) As described above, your home computer will then be reachable with PC.SUB.DOMAIN.TLD.

Redirect SUB.DOMAIN.TLD to your server

As I said, you need access to the zone file of DOMAIN.TLD. If you have, just insert this line:

replacing SUB with what you want to use as a subdomain and YOUR.SERVER.IP.ADDRESS with the IP address of your server.
It will take a while for the DNS servers to update the zone.

Create the update scripts

To make your server aware of a change of your IP address, you have to tell it whenever you reconnect to the internet and are assigned a new IP address. We thus create two scripts in /etc/bind/zones/:

• updatescript
  #!/bin/sh
  # usage:  do-nsupdate [text-file-containing-nsupdate-instructions]
  nsupdate -y "rndc-key:YOUR_RNDC_KEY" -v $1
• updatefile
  server SUB.DOMAIN.TLD
  zone SUB.DOMAIN.TLD
  update delete PC.SUB.DOMAIN.TLD A
  update add PC.SUB.DOMAIN.TLD 86400 A 0.0.0.0
  show
  send

Replace YOUR_RNDC_KEY with the secret value in /etc/bind/rndc.key and edit the updatefile according to your data.

Replace the IP address and run the updatescript

You will now need the following, and I will leave it up to you how you do this. (I would be glad about nice solutions in the comments!) Whenever you reconnect to the internet (there are hooks for WICD, NetworkManager etc. that you can use), update the 0.0.0.0 in /etc/bind/zones/updatefile with your home computer’s new IP address and run /etc/bind/zones/updatescript /etc/bind/zones/updatefile and your zone file will be updated.

I myself solved this with a small PHP script, reading out the requester’s IP address and then updating and running the DNS update:

However, there certainly are nicer solutions involving just one request. One can, for example, read out the IP address when using an SSH request and then just execute the above commands over SSH. This would be more elegant than my solution.

The hook for WICD would be placed on your home computer in /etc/wicd/scripts/postconnect/hook.sh and will be executed after successfull connection to the internet. NetworkManager stores it’s hooks in /etc/NetworkManager/dispatcher.d. You have to google to find the appropriate way to use these hooks.

Soooooooo…

I hope I could be a bit helpful, and at least make clear how you can use your own server to act as some Dyndns-like service. If you succeed in setting the service up following my guidelines and/or if there is something missing here, I would be glad about a comment.

• I can separate all the webserver and scripting language stuff from my root filesystem
• It is portable
• I can use a distribution similar to the one running on my (real) webserver, which makes deployment easier.
• It works (nearly) exactly as if I used the main filesystem, since today’s computers are powerful and memory big enough.

I will outline briefly what I did:

1. Install Debian in a VirtualBox VM without graphical interface (that option is displayed during the Debian installation)
2.  Start the VM once with VirtualBox and configure SSH access.
3. Configure Port forwarding for ports 80 and 22 (HTTP and SSH) in VirtualBox: Go to the “Network” Settings of the VM, expand the “Advanced Settings” of “Adapter 1″ (should be attached to NAT) and click on “Port Forwarding”. Now map the host ports 8080 and 2222 to 80 and 22 respectively. (You can of course feel free to use the ports you like)
4. When SSH access (localhost:2222) works, shut down the VM. You will now always use the VBoxHeadless tool to start it, which starts the VM in the background. (Attention: Don’t forget it after you are done working. It eats up a lot of memory!)

To control the VM and ease access to it, you can create an init script or a systemd service. Here is the latter one I use:

Also, you should configure your SSH to have an easy shortcut to access the server:

There are two options to work on the files.

1. Use sshfs: sshfs SHORTCUT webserver/ and then work within this directory. (It mounts the webserver using SSH) This is my preferred way, since the files are then stored on the VM.
2. Use Virtualbox’s shared folder feature.

All urls defined in /etc/hosts on the host machine should be redirected on the vm if you append :8080 to the address.

I hope, some of you find the idea useful.

Have a nice valentines and free software day!

Now, starting the GUI to start a VM is a bit slow, so VBoxManage startvm "vm" is a huge time- and memorysaver.
Since I work with Openbox, the natural thing for me was to google for a suitable pipemenu. Unfortunately, I couldn’t find one. Long story short: Here is my self-written Openbox pipemenu to control VirtualBox’s VMs. (It can start and stop them, at least.)

Put it somewhere, make it executable and set it as a pipemenu in your menu.xml file.

To set whether VMs should be powered off or if their state should be saved, edit the value of killAction in the script.

Here is my setup on how to work with emacs and use it as an editor for quickly editing files on the command line.

Starting the daemon using systemd

I switched from sysVinit to systemd some time ago, so the most convenient thing to do is to start the emacs daemon using a custom systemd service file. Put the following code into the file /etc/systemd/system/multi-user.target.wants/emacs.service:

Make sure you insert your username in the bottom line. Now, enable the service executing systemctl enable emacs.service and after the next boot the daemon is started automatically.

Shell aliases and sudo-ing

One thing you will quickly notice is that sudo emacsclient ... doesn’t work since the daemon runs under your username. To be able to edit files as root, we need to load the tramp plugin of emacs. Put the following line somewhere in your .emacs or .emacs.d/init.el:

Now, you would use emacsclient -c /sudo::/etc/somefile which is still a bit too long for quick file editing. (As well as the emacsclient command itself). This is why we create shell aliases. I am using zsh which is why I will use its syntax here.

It sets emacs as the default editor and defines the commands ec (emacs in a separate window) and et (emacs in the terminal) as well as its sudo friends for write-protected files, ecs and ets. Simply put the code in your .zshrc or .bashrc (after editing it to fit bash’s syntax) and restart the terminal. Then you can use ec/et/ecs/ets /some/directory/some/file to edit the file. I think tramp uses ssh to connect to your pc as root, so you might need to install ssh to use it.

The reason is that ReMoot only looks for programs that belong to the current user, while the mpd most of the times has it’s own user. (At least that is what’s proposed for example here)

To get ReMoot running with mpd you have to do the following two things:

• ReMoot uses mpc to interface with mpd, so make sure it is installed!
• edit /usr/bin/daemoot (or whereever it may be) and change line 470 (version 0.9 of ReMoot) to my @apps = `ps -L -u $ENV{USER},mpd -o comm,lwp`; where, of course, mpd has to be the user the mpd runs under.

That should be it. Have fun!

• I switched to linux
• I decided to use Pidgin instant messanger
• I hated the big, fat, ugly status bar in pidgin
• I wasn’t able to find a plugin that hides it (and does nothing more)
• So I wrote my own

It is just for Unix (I guess..) and you have to build it yourself. A small README is included in the tarball.

Sourcecode hidestatusbar.tar

I hope it helps anybody.

All the best, Oli

I will presume you know more or less exactly what these software packages do, and how to use them. Also, I assume that you are able to set up a virtual host by yourself. You should be familiar with how to use a command line, too!

Step 1 – Download libraries and set up the project

First of all, we need to download the libraries and set up our project.
Start with the Zend Framework. Go to it’s download page and download (at least) the minimal version. Right now, it is ZF 1.11.3. Unpack the download, go to a command line (whichever your system provides), change to the bin/ folder of the package and type the following lines:

This is what you do on a Unix shell. It is slightly different on Windows machines, there you would have to use the zf.bat file. However, you will have to figure out how to do that on your own, since I don’t work on Windows and am too lazy to google it right now.

Your project should be created now, meaning that the folder /path/to/App should contain several subfolder such as application/, library/ and so on. We create a subfolder with the name bin/ in this folder.

What has to be done next is to move all the libraries into our project. First of all, in the downloaded package of the Zend Framework, there should be a libraries/ folder containing another folder named Zend/. We move that Zend/ folder into the library/ folder of our project.

We then go on by downloading the Doctrine packages. I say packages, because we need the Doctrine ORM as well as the DBAL and the Doctrine Commons project. Luckily, all of them are included in one package, which can be downloaded on the Doctrine ORM’s download page. It is the latest Doctrine package. (As of now, it is version 2.0.1) Unpack it and simply copy the Doctrine/ folder into our project’s library/ folder.

The last step in setting up the project is to move or copy the contents of the bin/ folders of both downloaded packages into the bin/ folder that we just created in our project.

Step 2 – The configuration file

In this tutorial, I will show how to integrate Doctrine using MySQL as database engine. The config settings might be different for other engines or when you use different database interfaces. However, we open the application/configs/application.ini of our project and insert the following lines into the [production] block of the ini file.

At this point, you have to fill in your personal database connection settings. These might be completely different from the ones shown here. You should also adjust the database driver now, when you don’t want to use MySQL.

Step 3 – Bootstrapping

Now comes the fun part. We have to load all the Doctrine libraries and set them up correctly. To do that, we open the application/Bootstrap.php file of our project and fill it with the required functions. I will first post the whole file here and explain it below.

The first two methods don’t have anything to to with Doctrine. We just want to use a registry in our project (later, our EntityManager instance will be stored here!) and we want to register a namespace Default_ for use in our project. These methods are pure Zend Framework-ish, so I assume you know what they do. If not, consult the ZF manual.

Now for the _initDoctrine() method. The first thing we do in line 33 is to include the class loader of Doctrine. Unfortunately, Doctrine already uses the new namespacing of PHP 5 (or 6?). The Zend Framework doesn’t. So we need another class loader with the correct namespacing scheme. We set it up in the following five lines 34-38, telling it that we need the namespace Doctrine and where the include path of the library is.

We then create a Doctrine Configuration instance and configure Doctrine (lines 41-59). Depending on how you want to control the database scheme and stuff like that, you might want to adjust some of the settings here. The ArrayCache can be changed and set to something more performant and if you don’t want to use annotations in the Entities to define the database scheme, you should use a different MetadataDriver. In this tutorial, we use both the ArrayCache and the DefaultAnnotationDriver. When we instantiate the last one, we have to tell it where our classes with the annotations (I will talk about these more, later) are.

I never _really_ understood what the Proxy classes are. They are created at runtime by Doctrine and my guess is, they are to speed up the database interaction by sort of caching joined requests. Anyways, we need to define where these classes should be saved and what namespace that is. This is done in lines 57-59.

After that, we get our connection settings from the application.ini file and can finally create the EntityManager instance by telling it all our configurations and connection information. This EntityManager can be understood as the interface between the Database and our models (called Entities). We are saving it’s instance in the Zend Registry we created earlier.

And that’s it. We can now start creating Entities (models) and trying to do some database interaction!

Step 4 – The Entity

To test everything, we create a small dummy Entity. I will not go into detail on how to create Entites and define the database scheme of their tables. As we defined in the Doctrine config earlier, we want to use annotations (in the Docblock of our Entity) to define the database scheme. We create a file application/models/Test.php and fill it with the following code:

As you see, we want a models with the fields id and name, id being an integer and auto_incremented and name being a string. The table name is set to test123. As you can see, an Entity is nothing more than a PHP class with some members and methods. Only the definitions for how Doctrine should build the table have to be given in the annotations. You could as well use YAML or XML files to define these.

The next step is to adjust the command line tool of Doctrine to fit into our project.

Step 5 – the command line tool

Simply copy the following code into bin/doctrine.php replacing all of the code already in the file.

We do some bootstrapping of our project here to obtain the EntityManager instance. We then create a HelperSet with the EntityManager and run the cli tool.

To create our database table based on the Entity we created earlier, we open a command line, change into the bin/ folder of our project and run

Again, this is for the Unix shell and is different on Windows machines!
Fire up your favourite database administration tool and have a look! The table test123 should have been created properly.

Step 6 – Using the database

I will just post a small example of how to use everything. Replace the content of your application/controllers/IndexController.php with the following:

This is just some quick and dirty dummy code to check if everything works. We get our EntityManager out of the registry and save it as a member of the Controller. We then create a new model (Entity), set the name and by using the EntityManager‘s persist method, we save it. EntityManager->flush() actually invokes the database action and the row should occur in our table.

Test this by simply browse to your project in your favourite webbrowser. If everything worked fine, the table should now have one entry with the name Zaphod Beeblebrox.

If anything did not work, feel free to ask in the comments here! I will be glad to answer any questions.

So I started diving into Android development last autumn and today, just for fun, I tried to use some sensors included in my phone. (HTC Desire running Android 2.3.1)

My idea was to use the accelerometer along with the orientation measurement to measure both the distance the phone was moved and also it’s trajectory. Both values, of course, relative to the starting point of the motion.

So the first difficulty was to transform the measures of acceleration into the coordinate system of the lab (room…). Luckily, Android provides methods that need the acceleration and the magnetic field as input and return the transformation matrix for vectors. (Have a look at SensorManager.getRotationMatrix()).

The next thing I had to take care of was the earth acceleration. Trying to just remove a constant offset from the z-component of my acceleration vector wasn’t really accurate. (Somehow my phone measured the gravity to somewhat around 10.5 m/s^2…) So I just moved to the SDK version 9, which is Android 2.3, and used the sensor type Sensor.TYPE_LINEAR_ACCELERATION. This is the measured acceleration where the gravity was already taken care of.

Now, I took care of everything: I measured the acceleration and transformed it into the room’s coordinate system (before each measurement step, so that I could rotate the phone however I like and it wouldn’t change the measured values). After integrating everything my app was perfect and ready for a tryout.

Walking through my room and trying to measure the distances from wall to wall didn’t work at all. Moving the phone in a circle resulted in a measured distance of about 20+ m, which had to be wrong, too.

I don’t know yet what went wrong or whether it’s just the unprecision of the sensors. However, I will attach the source code of my activity and the layout file. Keep in mind that you need a phone running Android 2.3 to try it. The emulator can’t be moved, so It would be useless to emulate the app.) Please excuse the bad coding style, it was just meant to be an experiment.