Vargoville

Fixing Old Themes for Enlightenment 17

Tue, 01 May 2012 00:00:00 GMT>

My window manager of choice is Enlightenment 17, which has been in development for at least the past seven years, when I started using it. While generally awesome, e17 has never had a stable release, which means that features sometimes break. Last November, my theme of choice, Milky’s, stopped displaying the titlebar properly. Since the last release of the theme was from early 2010, I finally decided to learn about the e17 theming system and fix the problem.

The only post I could find of someone with a similar issue was here. My problem can be summarized as follows: the title bar became extremely short after the upgrade, as shown in the screenshot below. The titlebar text was unreadable. The close, minimize, and maximize buttons were unusable.

Before fix:

Without any good leads, I decompiled the edje theme file with edje_decc and had a look around. The theme comprised of almost 44,000 lines of styling. Wow. Luckily, the border file, milky_border.edc, where I figured my problem was located, was only ~7500 lines long. Of that, only ~1000 lines, not including support macros, were for the default border group, which is where I was experiencing my error. If I could fix the default border type, then I could fix the other border types as well.

Before starting this experiment, I knew nothing about edje files, so the following could be completely wrong. However, it appears that, at some point, the interpreted behavior for text switched from “fit the text into the box” to “let the text overflow the box.” (Alternatively, see the note at the end of this post, which notes how this might work.) The height of the text was the primary driver behind the height of the title bar, so after this change, only the border regions of the title bar were visible. Since these border regions were the same color, and the text overflowed, it looked like the border had shrunk.

Solution: make the text area have a minimum size. The default theme file does not set the minimum height of the font size text area in pixels — indeed, I have not taken the time to understand how the default theme is working without a height set — but a kludge for Milky’s theme is to set the minimum height of the text area to the font size of the text; this is 10 pixels for Milky at normal DPI settings. Voilà, the theme looks proper once again. Ideally, the text area should resize itself to match the height of the text, but I have not yet figured out how to make this happen. (Again, see the note at the bottom.)

After fix:

Specific to Milky’s theme, the following should be in the milk_border.edc file within each border group:

part {
   name:           "title2";
   type:           TEXT;
   mouse_events:   0;
   description {
      state: "default" 0.0;
      align: 1.0 0.0;
      visible: 0;
      min: 0 10;               // this is the new line
      rel1 {
         relative: 0.0  0.0;
         offset:   0    3;
      }
      rel2 {
         relative: 0.0  0.0;
         offset:   0    3;
      }
      text {
         text_source:   "e.text.title";
         source:        "e.text.title";
         min:           0 1;
         text_class:    "title_bar";
      }
   }
}

The line marked above should be added to every title2 section in the file, so that each border type is corrected. To recompile the theme into a theme file, run the build.sh script, and import the resulting *.edj file.

The “correct” fix: It seems that the “min: 0 1;” line in the text portion of the part should prevent the part from being resized to smaller than the text, depending on the values. However, no combination of values seemed to produce the desired effect, so I have left the line as-is, as there appears to be a further intricacy that I have not yet discovered.

Finding and Eliminating Duplicated Files

Wed, 25 Apr 2012 00:00:00 GMT>

Fancy file systems are all the rage. ZFS, btrfs, and even Microsoft’s new ReFS include data deduplication features. However, these techniques can use a lot of memory, and new file systems are often not nearly as stable as tried and true file systems, such as ext3/ext4 or XFS. Experimenting with file systems is fun; however, in this case, I am not about to trust all of my data to a new file system just to remove duplicate files. Instead, I decided to deduplicate my files using a few scripts. The end result: over 12GB of saved space after just a few minutes of scanning my hard drive. With hard drive prices sky high (but slowly coming down), this will help me last another 6 months before I have to upgrade my hard drives again.

Out of approximately 1TB of data, I had 24G of total space occupied by duplicated files. This means that, at a minimum, I should be able to save 12G of space, assuming there are only two copies. However, for many of my photos, it turned out that I had three or four copies in different directories. RAW photos are on the order of 15MB each for my camera, so this is quite a bit of wasted space. Now, I have largely eliminated duplicated files through removing excess files and hardlinking the remaining files. I use hardlinks for pictures, since I often to have a single picture in more than one directory, for easy browsing.

Here is my quick script that will generate a SQLite database containing the md5 hash of every file in the current directory that is over 1MB in size:

#!/bin/bash
# creates an index all files in the filesystem, path and md5
# the database is named "index.db"
# bvargo

DBFILE='index.db'

# creates the databse
rm -f $DBFILE
sqlite3 $DBFILE "CREATE TABLE files (md5 text, path text)";

# the magic that does everything
find . -type f -size +1M -print0 \
   | xargs -0 md5sum \
   | sed 's/^/INSERT INTO files (md5, path) VALUES ("/; s/  /", "/; s/$/");/' \
   | sqlite3 $DBFILE

Why the 1MB? I have a lot of code, and SVN and git tend to duplicate a number of files. For instance, many git scripts are duplicated between repositories. I do not wish to eliminate these duplicates, as I may change the files in the future. Since they do not contribute much to the total hard drive space used, I can skip them. Skipping small files also has the advantage of skipping a large number of files, reducing the number of hard disk seeks, and thus speeding the process of indexing the drive.

If you wish to change this property, change the +1M in the find statement above. The rest of the find statement is just finding files under the current directory and printing the filenames, delimited by null characters. xargs is then running md5sum on each file. The sed ~~statement~~ hack converts the md5sum output to SQL. The SQL is passed to SQLite without any intermediate files.

Once we have our index file, index.db, we can find duplicate files. The SQL statement will find all files that have an md5 hash that matches another file in the database. The name of all duplicated files is printed, along with the hash. From there, eliminate all except for one of the files to remove the duplicate entries. The utility is not smart enough to figure out which files you want removed and which files you want to keep!

# find duplicate files
# replace $DBFILE with index.db if running from the command line
sqlite3 $DBFILE "SELECT md5, path FROM files WHERE md5 IN
      (SELECT md5 FROM files GROUP BY md5 HAVING COUNT(md5) > 1)
      ORDER BY md5;"

Before we delete anything, if you want to see how much space is taken up by files in the output set, run the following command. This is where I got the 24GB number from, as I noted above. Divide by two to get the minimum amount of space that you can save.

# to get the size saved:
# replace $DBFILE with index.db if running from the command line
sqlite3 $DBFILE "SELECT path FROM files WHERE md5
      IN (SELECT md5 FROM files GROUP BY md5 HAVING COUNT(md5) > 1)
      ORDER BY md5;" \
   | tr '\n' '\0' \
   | du -shc --files0-from=-

Happy deduplicating!

Disclaimer: The SQL generation method is not completely robust, as it depends on the output format of md5sum. However, the null-delimited entries should mean that the script should work on all filenames, assuming the md5sum output remains constant. The last script snippet will break on file names that contain newlines, since I knew that none of my files contained newlines.

Hello World

Sun, 01 Jan 2012 00:00:00 GMT>

Hello world! Again. Keeping with the tradition of writing more blog engines than blog posts, I now have two new blog engines. I began writing a static blog site generated from source markup using shell scripts, but then I discovered jekyl and hyde. I decided to go with jekyll. All of my old blog links should still work, but now it is easier for me to write new blog posts (go vim!).

My New Year’s resolution is to publish more of my projects (code or otherwise), so hopefully I will get around to posting about interesting things here. To start with, check out the two plugins I wrote for this blog on github. The plugins create the tag pages and post summaries.

Lenovo T420 Internal Microphone and Linux

Sat, 24 Sep 2011 00:00:00 GMT>

I recently — by which I mean probably 6 months ago — bought a Lenovo T420. The machine is amazing, except on one point: the microphone and headphone jacks are combined. For work, I need to be able to use Skype; it’s not my favorite program in the world, but hey, it sort of works when the weather is right and the stars are aligned. However, with the integrated microphone/headphone port, I had a problem: I could not connect a microphone while still using my laptop’s speakers. The T420 also includes a built-in stereo microphone, but this did not work correctly under Linux. I needed to make the internal microphone work.

It turns out that I had too many audio drivers installed, since I had started with a liberal, non-tuned kernel configuration. Device Drivers → Sound → ALSA → PCI sound devices → Intel HD audio → Conexand HD-audio codec support is the only required option. I also enabled reconfiguration support, jack plugging notification, and the HDMI drivers, as well as power saving. Now the internal microphone shows up as Capture in alsamixer. To enable capture, press spacebar in alsamixer so that the L and R indicators come up along with “CAPTURE”.

Now both the microphone and video camera work. (To get the video camera working, enable Device Drivers → Multimedia support → Video capture adapters → V4L USB devices → UVC.)

Happy Skyping.

Copying Chromium/Google Chrome Search Engines

Sun, 29 May 2011 00:00:00 GMT>

Chromium (the open source version of Google Chrome) has a great search engine feature that allows the user to search different websites directly from the omnibox (the address bar). I use this feature heavily; for example, “wp Linux” means search Wikipedia for the Linux article for my browser, “bgo chromium” means search bugs.gentoo.org for all bugs containing the term chromium, etc. All of these search engine features are configured from the “Manage Search Engines” screen under Preferences. Chromium will even add search engines as it finds them, through metadata embedded in some pages. For example, Amazon has this feature embedded in its page, so searching “amazon.com Arduino” will search for the Arduino on Amazon.

But there’s a problem, aside from some people not like search engines being added automatically. While Chromium seems to sync almost everything between multiple computers, search engines are not synced. Read on for how the search engines can be transferred from one machine to another without having to enter them all by hand.

Update: Chromium now support search engine synchronization. See Issue 15548 for more information.

Backround

Chromium stores most settings in a set of SQLite databases. I will not detail SQLite, since the project has excellent documentation on the SQLite website, it will suffice to say that SQLite is an embedded, relational database. In particular, Chromium stores the search engines in a table called keywords in the “Web Data” database. These keywords can be exported and re-imported into another Chromium browser profile.

Getting Started

First, when doing any work with the SQLite database, ensure Chromium is not running. SQLite supports the locking of the database nicely, so you do not have to worry about corrupt data, but Chromium likes to keep the database locked more often than not.

Second, find the profile directory in which Chromium keeps its data. On Linux, this is ~/.config/chromium/Default/, for the default profile. On Windows, if you are running Chrome, the profile should be somewhere such as C:\\Users\\username\\Application Data\\Google\\Chrome\\Default, for Windows Vista or Windows 7. Please substitute this path where I write ~/.config/chromium/Default/ later.

Third, you will need the sqlite3 command-line interface for this tutorial, available from the SQLite website. This should already be present on most Linux machines and Macs. For Windows, choose the download page, and then look under “Precompiled Binaries for Windows,” particularly at the zip file with the shell.

Finally, please note that this will NOT synchronize the search engines. This is a one-way process, as written, though you could expand it to export from both computers, combine the results, and then use the new set of search engines on many computers.

Exporting the Data

Exporting the search engines is as easy as exporting the keywords table from SQLite. On the machine that you wish to export the search engines from:

sqlite3 ~/.config/chromium/Default/Web\ Data

This will start the sqlite3 command-line interface. Then, to export the data from the keywords table:

.output keywords_export.sql
.dump keywords
.quit

Now you have a file called keywords_export.sql in the directory from which you ran the sqlite3 command. Copy this to the machine on which you wish to import the search engines.

Importing the Data

Importing the data is even easier. Assuming that the export done in the previous step is called keywords_export.sql is in the working directory, the following will delete the old search engines and import the new search engines:

sqlite3 ~/.config/chromium/Default/Web\ Data "DROP TABLE keywords"
sqlite3 ~/.config/chromium/Default/Web\ Data < keywords_export.sql

The last command will not work in a normal Windows shell, which does not support file redirection nicely. Instead, use the following in place of the last command, remembering to substitute for the location of the Web Data database:

sqlite3 -init keywords_export.sql ~/.config/chromium/Default/Web\ Data .quit

Start up Chromium and see your search engines restored.

Conclusion

You should see your search engines copied from one machine to another. If you wish to see syncing of search engines in chromium or Google Chrome, please star Issue 15548 on the chromium project’s issue tracker. Not only are you letting the developers know you wish to see this feature, but you are notified of all future updates regarding the feature request.

Arduino Installation Notes

Sun, 29 May 2011 00:00:00 GMT>

I recently bought an Arduino Uno (thanks in part to SparkFun’s free day, thanks SparkFun!), and I have finally gotten around to hooking it up to my main Linux box, which runs Gentoo. Some notes on problems I encountered getting everything working:

1) The dev-embedded/arduino package in Porgage is extremely old. Use the overlay at git://gitorious.org/gentoo-arduino/arduino.git, or compile directly from the Arduino source.

2) Despite what online documentation may say, the Uno does not use a FTDI chip for serial communication, unlike the previous Arduinos. Instead, the ATmega328 firmware image takes care of the USB<—>serial communication. As such, a different driver is required. When configuring a kernel, enable CONFIG_USB_ACM (Device Drivers → USB Support → USB Modem (CDC ACM) support) for support. The Arduino will most likely show up as /dev/ttyACM0, assuming no other ACM devices are connected.

3) The Uno firmware may have a bug in it that causes issues under Linux, depending on the version loaded. To update the firmware, follow the instructions “here”: http://arduino.cc/en/Hacking/DFUProgramming8U2.

4) In Gentoo, there is a bug where the crossdev version of ld will not find the file avr5.×. For more information, see Bug 147155 in the Gentoo Bugzilla. For a quick fix, the following works, thanks to comment 61 on that bug, assuming an amd64 host:

cd /usr/x86_64-pc-linux-gnu/avr/binutils-bin/2.20.1
ln -sf /usr/lib/binutils/avr/2.20.1/ldscripts ldscripts

5) The Arduino version of avrdude is different than the stock version. The modified version of avrdude can be found in the Arduino github repository (git://github.com/arduino/Arduino.git). If you try to use the stock version, you will probably get an error that looks something like this:

avrdude: Yikes!  Invalid device signature.
         Double check connections and try again, or use -F to override
         this check.

Now everything works, and I’ve finally started a few new projects that had gotten pushed to the side for the past two years.

Introduction to awk

Sun, 07 Nov 2010 00:00:00 GMT>

awk is a pattern scanning and processing language that is commonly used to process tabular data by either transforming the data in some way or producing a report about the data. The language is turing complete, and at least the GNU version has file and network I/O capabilities. However, this introduction guide will not discuss the advanced features for the sake of brevity.

Common Usage

The most common, and probably the simplest, usage of awk is printing particular fields from a tabular data source.

Suppose that we have the following file, hp_dates:

Severus  Snape       January     9  1960
Arthur   Weasley     February    6
James    Potter      March       27 1960
Ron      Weasley     March       1  1980
Fred     Weasley     April       1  1978
George   Weasley     April       1  1978
Draco    Malfoy      June        5  1980
Harry    Potter      July        31 1980
Neville  Longbottom  July        30 1980
Ginny    Weasley     August      11 1981
Hermione Granger     September   19 1979
Bill     Weasley     November    29 1970
Lord     Voldemort   December    31 1926

Further suppose that we want to print the years of birth, omitting all of the other data. Notice how the number of spaces between each field is variable. One might be tempted to use the cut command to do this. However, this will not work well with this input due to the column-aligned data instead of delimited data. However, we can easily print certain columns of data by using awk:

awk '{ print $5 }' hp_dates

What this does is reads the file hp_dates and runs the command for each line. In this case, the $5 indicates that the 5th field should be printed; $0 is a special case where the entire line (really the entire record — see below) is printed. awk can also read from standard input, in which case the filename can be omitted. Also, notice how Arthur Weasley does not have a year associated with his birthday. awk will not throw an error in this case, but nothing will be printed for $5.

Further suppose that we want to output both the first name and the year of birth, and this time our data is coming from standard input. Again, this is done fairly easily with awk:

cat hp_dates | awk '{ print $1, $5 }'

How This Works

awk consists of pattern/action pairs. When awk is run, the input is split into a number of records. By default, these records are separated by the newline character; see the RS variable below. For each record, if a pattern is matched, the associated action is performed. The general format is as follows:

pattern { action1; action2 }

Each action can be separated by semicolons, as shown, or the actions can be separated onto multiple lines without using semicolons.

In the above examples, we omit the pattern, so the action will be performed for every line in the file. Also, we use a few default values above. The first default is the field separerator, by default whitespace. See the FS variable below. The second is the output field separator, which is inserted between the $1 and the $5 in the second example. This value is also a space by default. If we had omitted the comma, the two values would be printed together without any delimiter. See the OFS variable below. Finally, we use the output record seperator, by default a newline, which separates records on output. See the ORS variable below.

Special Variables

awk has a number of special variables, such as the OFS (output field seperator) that was already mentioned above. As the dollar sign is used to retrieve fields from a record, the variables should be used without a dollar sign. For example, the variable NF would give the number of fields, while $NF would access the last field.

Variables of particular interest:

NR – current count of the number of input records. The first record will be 1; the second will be 2, etc.
NF – the number of fields in the current record.
FILENAME – the current filename (- for standard input).
FS – the field separator. The default is white space, meaning either tab characters, space characters, or a combination of the two.
RS – the record separator. The default is a newline.
OFS – the output field separator, the value inserted for a comma, as shown above. By default this is a space.
ORS – the output record separator, the value that separates records for output. By default this is a newline.

See more special variables in the GNU manual.

Another Example

Suppose that we want to emulate wc and print out the number of lines, words, and characters.

awk 'BEGIN { print "File statistics (lines, words, characters):" }
{ w += NF; c += length + 1 }
END { print NR, w, c}' filename_here

This file is devided into three parts:

The first action is matched on BEGIN, which is a pattern that matches only when awk is first executed, even if multiple files are specified. Note that the FILENAME variable will be blank in the BEGIN clause, because awk has not yet opened a file.
The second action does not have a pattern, so it will be run for each line. w is storing the number of fields, in this case the number of words because the default delimiter is spaces and/or tabs. c adds the number of characters in each record, plus one to include the newline characters that are not a part of each record. length is actually a function, and is shorthand for length($0) (where $0 is the entire record). length returns the number of characters in the provided argument.
The last action is matched by END, which is similar to BEGIN but matches when awk is about to exit. In this case, we use it to print out the statistics that we accumulated for each record. Remember that NR is the number of records (lines), which is why we did not increase a counter for each record.

Other Patterns

Suppose that we want to print the first name and year of birth for each of the Weasleys, excluding everyone else. We could use grep:

grep Weasley hp_dates | awk '{ print $1, $5 }'

Alternatively, we could use the pattern feature of awk:

awk '{if($0 ~ /Weasley/) { print $1, $5 }}' hp_dates

The the if statement checks to see if the entire record contains the term Weasley. However, this is inside the action. Let’s make it a pattern:

awk '$0 ~ /Weasley/ { print $1, $5 }' hp_dates

Regular expressions are commonly used in this manner, so there is an even shorter expression:

awk '/Weasley/ { print $1, $5 }' hp_datesa

Note that there are no parenthesis around this shortcut. If parenthesis are added, the longer with the $0 should be used.

In the above output, Arthur Weasley, who does not have a year, is still represented. Let’s include only lines that have at least the number of records we want:

awk '/Weasley/ && NF >= 5 { print $1, $5 }' hp_dates

Try doing that with grep. The && is a boolean operator, which will act as one would expect (“and”). || is also available (“or”).

Finally, let’s print the entire record instead of just the first name and the year of birth:

awk '/Weasley/ && NF >= 5 { print }' hp_dates

Note that no argument is given to print. Like length, this will assume $0 as the argument, the equivalent of print($0), which prints the entire record. Note that when the record is printed in this way, the entire line, as it is originally represented in the file complete with spacing, is printed.

More on Patterns

Comma separated patterns can be used to turn an action on and off. Consider a file that has a START marker and an END marker around data that should be printed. We can print only the lines between these markers in addition to the markers themselves as follows:

awk '/START/,/END/ { print }' test_file

In the previous example, /START/,/END/ could be replaced with any conditional, such as (NF0),(NF2). The first pattern will turn on the action, which will run for each record thereafter until the stop condition is met, which will execute the action for the last time and turn it off.

One more final note on patterns and actions: each is executed independently of the others. This means that if two actions match a single record, and both print the record, then the record will be printed twice.

Further Information

This introduction has only briefely touched upon the basic features of awk. As I mentioned, the language is turing complete, and comes with much more functionality, including features found in most “normal” programming languages and libraries, such as for loops, complex if statements (with boolean operators), arrays (including multi-dimensional arrays and associative arrays), string functions, regular expressions, environment variables, number formatting (in addition to printf), random numbers, etc.

For more information about awk, particularly gawk (the GNU version), see the full manual or the man/info pages. This page is also a nice guide.

The Bluetooth Blues: Getting a Linux PC to use a GPS on an Android Device

Sun, 17 Oct 2010 00:00:00 GMT>

Bluetooth is one of the modern wonders of modern wireless technology. Whether you want to talk on the phone through your car or play a game on your Wii with a wiimote, you’re using bluetooth. It is wonderful, when it works. When it doesn’t, however, then it can be a royal pain.

I set out with a simple goal: let me laptop use my phone’s GPS. Easy, right? Well, not exactly.

Bluetooth on Linux has never been easy to work with, or at least I have not found the right tools to make it easy. Verion 4 of BlueZ, the Linux bluetooth stack, did not help matters much either. With version 4, all of the configuration files changed. All of the command-line tools changed. BlueZ shifted to becoming a D-Bus-centric service. That may be great for people who run KDE or Gnome and have a little panel applet to handle everything, but for me, the command-line user, all of my tools were taken away. For a long time, there simply were no command-line tools of the same quality as the old version 3 commands. You had to use D-Bus. I stayed at version 3 for a long time after it stagnated. It worked.

Fast forward a year of so. Gentoo added two use-flags for version 4 of BlueZ: test-programs and old-daemons. All of my old CLI tools are back in service. The new test programs also make several things much nicer.

Enough introduction. How do I get my Android phone’s GPS available to my computer? To do this, there are a couple different pieces of software that I used. BlueZ, obviously, for the bluetooth stack on the computer. (BlueZ is also used in Android, but you do not really see it, since there is a nice UI.) GPSd, the GPS service daemon, which is the de facto GPS API on Linux. On the phone, I use a tool called GPS 2 BT, which is available in the Market for free and outputs data in the NMEA format over bluetooth.

For the rest of this guide, I will assume that you have everything above installed. I will also assume that you are the root user when root permissions are needed. I will also assume that if you are not on Gentoo you can adapt the file paths / commands as needed.

Step 0: Figure out the MAC address of the bluetooth interface on your computer and phone

On the computer:

hcitool scan

Which will output something like this:

Devices:
   hci0     00:00:00:00:00:00

00:00:00:00:00:00 is the MAC address of your computer. Now for the phone. Turn on bluetooth in the settings menu (settings → wireless & networks → check bluetooth) and then enter the bluetooth settings menu. In the bluetooth settings menu, note the name of the device and then check discoverable, which will make your phone visible to other devices for two minutes. Back on the computer:

hcitool scan

Which will output something similar to the following:

Scanning ...
   11:11:11:11:11:11    phone_name_here

Step 1: Pairing the devices

Do not leave the settings menu yet. It turns out that it is easier to pair the devices by initiating the connection from the phone, rather than the computer. Back on the computer, make the computer discoverable by using the bluez-test-adapter script. Second, start a pin program that will prompt for a pin when ready to pair:

bluez-test-adapter discoverable on
simple-agent

Back in the bluetooth menu on the phone, click scan for devices and look for your computer in the list of devices. Click on the device and enter a pin, such as a four digit number. Back on the computer you should see a prompt in the window running simple-agent asking for the pin. Enter the same number and press enter. The pairing should be successful; the phone should list the computer with “paired but not connected” listed below the name of the computer. If this is the case, hit ctrl-c on the computer to close simple-agent, as we don’t need it anymore. Also, make the computer hidden again:

bluez-test-adapter discoverable off

Step 2: Setting up the GPS

Back on the home screen of the phone, tap the GPS 2 BT widget so that the slider on the right is up and the bar is green. This means that the phone is ready to accept GPS connections. Back on the computer, we are going to run a service discovery command to see that the GPS is indeed visible.

sdptool browse 11:11:11:11:11:11

Remember, 11:11:11:11:11:11 is the MAC address of the phone. Change accordingly for your phone. You should get back a bunch of different services, among which should be something similar to the following:

Service Name: Bluetooth GPS
Service RecHandle: 0x10003
Service Class ID List:
UUID 128: 00001101-0000-1000-8000-00805f9b34fb
Protocol Descriptor List:
"L2CAP" (0x0100)
"RFCOMM" (0x0003)
   Channel: 29

Step 3: Setting up RFCOMM

RFCOMM, which stands for radio frequency communication, is a protocol that emulates serial ports over Bluetooth. It can emulate multiple connections at once, so each connection is given a channel number. As an analogy, consider an IP and port in typical TCP/IP. The IP is sort of like the MAC in this case, and the channel is sort of like the port that the client connects to. This isn’t actually how it works, but it may be helpful to think about it in this way.

In the example above, the GPS is on channel 29 (last line of the output). Configure the RFCOMM connection, using that channel, by editing /etc/bluetooth/rfcomm.conf:

rfcomm0 {
   # Automatically bind the device at startup
   bind yes;

   # Bluetooth address of the device
   device 11:11:11:11:11:11;

   # RFCOMM channel for the connection
   channel 29;

   # Description of the connection
   comment "Android GPS";
}

Step 4: Configuring GPSd

Edit /etc/conf.d/gpsd, or the GPSd configuration file for other systems, to change the GPS device. Above, we named the RFCOMM connection rfcomm0. This will show up as /dev/rfcomm0. Use that device for GPSd.

GPS_DEV="/dev/rfcomm0"

Step 5: Test it out.

Make sure the GPS icon on the phone is green, bluetooth is enabled on the phone and the computer, and the configured RFCOMM channel matches the actual channel on the device. Start up gpsd (/etc/init.d/gpsd start). The daemon should be running now. Launch xgps, a test program included with GPSd, and see if it shows you your location. Try out other applications that use GPSd to get the location, such as kismet or gpsdrive. A list of many applications can be found at the GPSd homepage.

Troubleshooting
A few useful tools for debugging:

rfcomm unbind rfcomm0

and

rfcomm bind rfcomm0

This destroys and creates the /dev/rfcomm0 device. This is needed whenever you reconfigure the RFCOMM settings. Restarting the bluetooth service should work too, but the commands above ensure the job gets done.

You can manually connect with:

rfcomm connect rfcomm0

However, the bluetooth connection should be started when GPSd is started, as GPSd tries to read from the file, so this should be unecessary.

If you have the Android development tools installed, you can run the following to print the Android log:

adb logcat

Finally, if you keep getting errors, check your RFCOMM channel. For some reason, whenever I disconnect from the GPS or restart the Android widget, the RFCOMM channel changes. I have yet to find a better way to discover the correct channel each time.

Dynamic Ticks for Operating Systems

Mon, 13 Sep 2010 00:00:00 GMT>

Last week, I asked in my OS class how tickless operating systems use interrupts or other mechanisms to achieve lower power usage. I did not get my question answered, and have since read into the topic some more. Here is what I found.

Warning: I am not a kernel developer. I am a student. Some of this information may be outdated or outright wrong.

Background:

“Normal” operating systems use system timer interrupt (a periodic timer “tick”) that fires on a periodic interval. This allows the kernel of the OS to update internal counters, perform any accounting, and switch processes (perform a context switch) if the current process’ time slice is done. This method has two primary downfalls: kernel timer resolution is limited to the tick rate, and an idle system uses unnecessary power by waking up from a sleeping state, checking to see if anything needs to be done, and then going back to sleep. These two functions are linked together. Suppose I am creating a real-time OS that has hard latency requirements, and I want to ensure the system is always responsive. Further suppose that I want this real-time OS to run on an embedded platform with low power requirements. To achieve more accurate timers, and then lower latencies, I can increase the rate of the timer interrupt. However, this also uses more power, as the system uses the CPU and other hardware devices that may otherwise be idle to check if anything needs to be done.

In Linux, the duration of a single tick of the system timer is called a jiffy. The actual duration of a jiffy in seconds is platform-dependent. On my box, by default, the timer frequency is set for 300Hz, so the timer fires every 1/300 of a second, which is just over 3ms.

Now imagine that, even if your system is idle, it wakes up 300 times a second to see if it needs to do anything. However, at the same time, any system timers cannot be more accurate than 3ms, unless the rate is changed. This uses a lot of power if the system could otherwise be in a lower power state. As an analogy, consider setting your alarm clock so that you stop whatever you are doing every 4.8 minutes, even in the middle of the night, to see if it is time to go to class. You wouldn’t be able to get any sleep, and you would not be able to focus on what you are doing for more than 4.8 minutes. Furthermore, if you check if it is time to go to class 5.3 minutes before class, you would have to wait another 4.8 minutes before you check again and realize that you have to go to class. This could leave you running for class if it turns out you only have 30 seconds left before class starts. Wouldn’t it be nice if you could set the alarm clock so that it left you just enough time to get to class, and you wouldn’t have to check every 4.8 minutes to see if it was time to go? In other words, wouldn’t it be nice if we could set an accurate timer so that it would go off exactly when we needed it to?

In this analogy, the course of the day is a second for your computer, and checking if it is time to go to class is equivalent to updating the computer’s internal counters and checking for timer events. Hardware devices generate interrupts when they have something to say; wouldn’t it be nice if we could do the same for internal software events too? Clearly the case of checking the clock every 4.8 minutes to see if it is time to go to class is not optimal. If you really want to extend the analogy, consider the context switch to be the 30 seconds it takes you to roll out of bed and wake up. Having an alarm clock go off exactly when it needs to is the equivalent of a controllable timer interrupt; the timing is far more precise compared to checking the clock every so often, and you get some sleep at night.

Enter tickless operating systems.

Tickless operating systems abolish the periodic tick, either when idle or completely, and use specific hardware to only wake up when necessary. This saves power when idle, and gives more processing time to the user when not idle. It also allows the accuracy of internal timers to be as accurate as the hardware allows, as there is no power/accuracy tradeoff. For example, if the OS knows that it does not need to wake for another 1.5 seconds, for example when the system is idle, then it can put the processor in a low power state for the entire 1.5 seconds. Hardware interrupts can still wake the system, so this is transparent to the user if implemented correctly. These little power savings add up.

There is still a timer interrupt that is fired when requested, but the difference is that the OS is specifically requesting the timer to fire at a certain time and only when needed.

More information:

I mainly referenced Linux while looking for the answer to my question, as that is what I use, and the sources and developer messages are available for browsing. Of course some of this is probably oversimplified. For more information for Linux, which will also turn up general information, look for NO_HZ, dyntick, clockevents, or high resolution timers. NO_HZ is the kernel option that makes the OS tickless. dyntick and clockevents are part of the kernel. High resolution timers are more general. Linux has had a number of architecture-specific implementations of dynamic ticks since it was implemented for the s390 architecture in 2.6.6 in 2004. clockevents and dyntick, which provide a general API for timing events, were merged into the mainline kernel for 2.6.19 in early 2007.

Interesting links:

Backgrounds

Mon, 13 Sep 2010 00:00:00 GMT>

If you hadn’t noticed, the background on this site changes every time you load the page. While I’ve had the background collection for some time — since high school actually — I had forgotten that some of the backgrounds actually came from one of my friends, and I did not attribute this fact. I would like to fix this, especially since he made the cool images himself in gimp and has graciously let me continue using them. Take a look at his high school site, where he has some more cool artwork in a changing background. You’ll also notice that his loading mechanism is more efficient than mine.

Some of the other backgrounds come from another project I used to work on during high school, iodine, our school’s intranet.

New Blog Engine

Thu, 19 Aug 2010 00:00:00 GMT>

I haven’t updated this blog in awhile, and this is partly due to the fact that I disliked the blog engine I was using, Serendipity. It’s not that Serendipity is bad, but rather that it simply tries to do too much. It is too flexible, at least for what I needed it for, but yet some things that I consider core features did not work properly. The biggest issue I had was combining markup and code syntax highlighting (geshi). In addition, once I had written a post and it looked good in the preview interface, the published version always differed in some way.

I have developed my own blog engine now. It has three simple features: posts (with code syntax highlighting and markdown), comments (also with code syntax highlighting and markdown), and RSS/Atom feeds. Will this make me update this blog more often? I do not know. At least the blog engine will not be in my way anymore.

Functional Programming with PHP

Sat, 12 Jun 2010 00:00:00 GMT>

Wait, what? You can do functional programming in PHP? Doesn’t that make PHP even more messy? Why would you do such a thing? In this case, no, it makes my code cleaner.

Background: I am developing an application (in PHP – no comments on that please) that uses a MVC architecture (Model View Controller). I designed the framework myself, with some helper functions pulled from an older project that I used to work on. There is no cruft; there is little messiness associated with PHP projects; it does only what I need in a logical manner. More importantly, the framework lets me focus on my application without having to worry about backend stuff. For database access, I use ADOdb with an OOM similar to ActiveRecord. For templates, I use Smarty.

Across many pages in my application, I need to sort tabular data that is displayed to the user. Seems simple enough, right? Django handles this by having an inner class, Meta, that can define the ordering of objects returned from QuerySets. That, in my opinion, is the wrong way to go about sorting data in a template. Why should my model be defining the order in which data is displayed to the user? django-sorting has some automagic sorting functions, but there is no way to specify the default sorting order. Back in my PHP application, I did not want to specify the sorting order in my PHP code. The sort ordering belongs in the template, from which the data is displayed. Since I use Smarty, I had to find a way to make this happen. My solution is a Smarty attribute, sortby, which will magically take a string of fields to sort by and somehow sort the data.

First, let us attack the problem of sorting itself. PHP has an array of sorting functions: sort, uksort, usort, and uasort. All, except for sort, take a callback comparison function that is responsible for comparing two elements. Even C has something similar; qsort takes a base pointer, the number of elements, the size of each element, and a function pointer to a comparison pointer. Back to PHP, this means we would do something like this for something simple:

// the comparison function
function compare($a, $b)
{
   if($a == $b)
   {
      return 0;
   }
   return ($a < $b) ? -1 : 1;
}

// some initial data
$array = array(1, 5, 2, 5, 7, 8, 9, 8);
// actually do the sort
usort($array, "compare");
// do stuff with sorted data here

However, those comparison functions get redundant and messy. PHP allows anonymous (lambda) functions, so we could do something like this:

// some initial data
$array = array(1, 5, 2, 5, 7, 8, 9, 8);
// sort, defining the comparison function as an anonymous function
usort($array, function($a, $b)
{
   if($a == $b)
   {
      return 0;
   }
   return ($a < $b) ? -1 : 1;
});
// do stuff with sorted data here

Maybe that is a little better; I personally think it is still messy. What if I want to sort multiple items though? I have to define that comparison function twice now, if I still want it to be an anonymous function. More importantly though, this does not work in Smarty. I do not want to be writing sorting PHP code in my template. What I need is a function that will write a sorting function for me. I want to be able to do something like this:

// some initial data - instances of the Person class
//$people - assume it's already assigned
// actually do the sort
uasort($people, sortby("first_name", "last_name", "-#age"));

That would be awesome. I do not have to worry about defining my own comparison function. sortby somehow knows how to access the correct fields of my People class and produces a comparison function that will first try sorting by the person’s first name, then the last name, and then the age, in reverse. The “-#” means that I want age to be sorted in a numeric manner and in reverse. Let’s see how we can make this happen. My solution:

  1 // generates a function that can be used for comparisions while sorting
  2 // in order, compares by:
  3 //    object->field()
  4 //    object->field
  5 //    object['field']
  6 // if a field is not given, then the data is compared directly
  7 // modifiers:
  8 //    prefix '-' to do a reverse sort
  9 //    prefix '#' to sort numerically / direct comparison
 10 //    prefix '-#' to sort numerically / direct comparison in reverse
 11 // example:
 12 //    sortby("-name, #age") returns a function that first compares name in
 13 //    reverse and, if those are equal, then compares by age numerically
 14 function sortby($sortby)
 15 {
 16    // caches generated functions
 17    static $sort_funcs = array();
 18 
 19    if(empty($sort_funcs[$sortby]))
 20    {
 21       $code = "\$compare = 0;";
 22       foreach(split(',', $sortby) as $key)
 23       {
 24          $direction = '1';
 25          $number = 0;
 26          if(substr($key, 0, 1) == '-')
 27          {
 28             $direction = '-1';
 29             $key = substr($key, 1);
 30          }
 31          if(substr($key, 0, 1) == '#')
 32          {
 33             $key = substr($key, 1);
 34             $number = 1;
 35          }
 36          if($key == "")
 37          {
 38             // assume a direct sort of data, since no fields were given
 39             $code .= "
 40             \$keya = \$a;
 41             \$keyb = \$b;
 42             ";
 43          }
 44          else if(is_numeric($key))
 45          {
 46             // must be the index of an array - variables/functions start with
 47             // letters
 48             $code .= "
 49             if(is_array(\$a) && is_array(\$b) && isset(\$a['$key']) && isset(\$b['$key']))
 50             {
 51                \$keya = \$a['$key'];
 52                \$keyb = \$b['$key'];
 53             }
 54             else
 55             {
 56                // bad key given
 57                \$keya = 0;
 58                \$keyb = 0;
 59             }
 60             ";
 61          }
 62          else
 63          {
 64             $code .= "
 65             if(is_numeric(\$a) && is_numeric(\$b))
 66             {
 67                \$keya = \$a;
 68                \$keyb = \$b;
 69             }
 70             else if(method_exists(\$a, '$key') && method_exists(\$b, '$key'))
 71             {
 72                \$keya = \$a->$key();
 73                \$keyb = \$b->$key();
 74             }
 75             else if(isset(\$a->$key) && isset(\$b->$key))
 76             {
 77                \$keya = \$a->$key;
 78                \$keyb = \$b->$key;
 79             }
 80             else if(is_array(\$a) && is_array(\$b) && isset(\$a['$key']) && isset(\$b['$key']))
 81             {
 82                \$keya = \$a['$key'];
 83                \$keyb = \$b['$key'];
 84             }
 85             else
 86             {
 87                \$keya = 0;
 88                \$keyb = 0;
 89             }
 90             ";
 91          }
 92          if($number)
 93          {
 94             $code .= "if(\$keya > \$keyb) return $direction * 1;\n";
 95             $code .= "if(\$keya < \$keyb) return $direction * -1;\n";
 96          }
 97          else
 98          {
 99             $code .= "if ( (\$compare = strcasecmp(\$keya, \$keyb)) != 0 ) return $direction * \$compare;\n";
100          }
101       }
102       $code .= 'return $compare;';
103       $sort_func = $sort_funcs[$sortby] = create_function('$a, $b', $code);
104    }
105    else
106    {
107       $sort_func = $sort_funcs[$sortby];
108    }
109    return $sort_func;
110 }

Whoo. Get all that? Let’s go through some it.

Lines 17-19: $sort_funcs is an associative array. After the sortby function produces a comparison function and “compiles” it into an actual function, it caches it so that further sorts will use use the already-created function. Why generate the same function twice?
Line 21: $code is going to be a string that makes up the function we are building. We will turn it into an actual, callable function later.
Line 24: $direction and $number control which direction we will sort in for a particular key and whether the sort is numeric (“100” < “90” but 90 < 100)
Lines 26-35: Set $direction and $number appropriately for the current key.
Line 36: If someone calls the function with sortby(’’), assume that we want the elements of the array to be directly compared.
Line 44: If someone calls the function with sortby(“5”), assume that the elements being sorted are themselves arrays, and we want to sort by a particular element of the array. Functions and variables cannot start with numbers.
Line 62: With the other checks out of the way, try to figure out what the passed arguments actually are. Are they numeric (line 65)? Are they methods that we should call (line 70)? Are they attributes in the object (line 75)? Are they keys in an associative array (line 80)? If none of these are valid, set $keya and $keyb to 0, and sortby just won’t sort the function.
Lines 92-100: Add code that returns the proper response for the field.
Line 22 – 101: All of this is in a loop for each field that is to be sorted. Additional code is added to the $code string to support supporting successive fields. The proper response is returned by lines 92-100 as soon as the two elements being compared are different, and the later code will not be run in this case.
Line 102: If we get all the way to this point, $compare will still be 0 because the two objects being compared appear to be equal, or none of the comparison methods work. Return.
Line 103: This is where the magic happens. This takes $code, which is still a string, and turns it into a proper callable function. It puts the function into the cache.
Line 109: This returns the sorting function.

So this function makes the magic “uasort($people, sortby(”first_name", “last_name”, “-#age”));" work pretty nicely. But how does this work in Smarty? It’s still a PHP function. One last little piece is required, a Smarty plugin:

// smarty modifier: sortby
// allows arrays of named arrays, objects with functions, or objects with
// fields to be sorted by a given field or fields
function smarty_modifier_sortby($arr_data, $sortfields)
{
   uasort($arr_data, sortby($sortfields));
   return $arr_data;
}

Call it modifier.sortby.php, to tell Smarty that this is a modifier, if you put it in a directory Smarty is already searching for functions. If you do not have such a directory, make sure the following line is run, which will add the modifier to a Smarty instance, in this case called $smarty.

$smarty->register_modifier("sortby", "smarty_modifier_sortby" );

Now I can use the sortby modifier in Smarty. Going back to my example of a Person, assume that a Person has a public variable $best_friend, which is another Person object. Now, using this Smarty attribute, I can do something like this in my template:

{foreach from=$people|@sortby:"best_friend->first_name,best_friend->last_name,#best_friend->age,-#age" item=person}

What will this do? It will loop over all of the objects in $people, sorted by the person’s best friend’s first name, the person’s best friend’s last name, the person’s best friend’s age, and finally by the person’s age (numerically, in reverse). Within the loop, the variable $person is available, so I can display the details of each person. How does the “best_friend→first_name” work? best_friend is a public variable in the Person instance stored in $people. In the sortby function, this expands to “$a→best_friend→first_name”, which is valid, so it works.

This sure beats writing a bunch of comparison code somewhere else in my application every time I want to sort something. Of course it may not work for everything; I have not thoroughly tested it. Released under the MIT license.

BitlBee - Changing the Way I IM

Sat, 22 May 2010 00:00:00 GMT>

It is not very often that a piece of software dramatically changes my workflow. A few years ago, I largely stopped switching OSes, browsers, email clients, window managers, IM clients, etc. I settled with what I had, as it was largely good enough. While I have switched browsers since then (Firefox → Chromium; more in another post), the workflow isn’t dramatically different. Most of the keyboard shortcuts are even the same. So after a friend pointed me to Bitlbee, an IM client, and I started to use it, I was hooked. BitlBee is an IM client, but it is unlike any other IM client that I have seen. I did not only change applications, but I fundamentally changed how I access IM services.

Traditionally, I have used Gaim for IM, even on Windows. Since I was running Linux, the standard AIM client (yes, they did have one!) was awful. I have no idea if it has improved since then; I have not looked. Eventually Gmail and Google Talk came around, so I added a Jabber/XMPP account to my arsenal. Then I was dragged into getting a Facebook account, and Facebook now supports Jabber/XMPP for chat as well. Gaim (now called Pidgin) let me keep up, and so I never switched to anything new. Somewhere in there I started using IRC, primarily for connecting to freenode. Pidgin is pretty awful when it comes to IRC; it simply is not built for it. Instead, I use irssi inside a GNU Screen session. I liked the always-on nature of irssi, as it runs on my server, and looked for a way to do the same with IM. I could use a text client, such as pork or mcabber, but then I would have one program for each protocol, which I certainly did not want. I could also switch everything to Jabber/XMPP, using transports for other protocols, but then I would still have irssi and some other piece of software for chatting. Enter BitlBee.

As I mentioned, BitlBee is a fundamentally different IM client. Not only is it a client, but it is also a server, an IRC server. It is not an IRC server in the traditional sense; instead, it presents all of your IM buddies as other IRC users inside a control channel (&bitlbee). Active users (not away or idle) are marked as having voice in the channel, while those that are away or idle do not have voice. To talk to a buddy, you can address chats to that user in the control channel, or you can query them. Unlike a normal IRC channel, only that buddy will see the text you address to them in the control channel. When a buddy logs off, the user leaves the control channel. Special commands in the control channel allow you to access more detailed information about the buddy, or you can use a standard /whois IRC command. More special commands allow for setting up IM accounts, accessing a full buddy list, etc. Let’s take a look at how to get started quickly with BitlBee. I’m only going to cover AIM and Jabber, as that’s all I use, but BitlBee supports other IM protocols as well, and it even supports Twitter.

Why is this important to me? It means I can access all of my chatting services, from Facebook to IRC, from a single client: irssi (or any other IRC client, should I decide to switch).

First step: Install and start the server.

As this is OS/distro-dependent, I’m going to skip this. I will assume you can figure it out. If you would rather use a public server, there are a number available, which are listed on the BitlBee website. However, I would recommend using your own, unless you want to give your IM passwords out to third parties.

Second step: Connect to the server from the IRC client.

/connect localhost

Substitute localhost with your server name, if applicable. Notice I used /connect, not /server. The latter will close any other IRC connections, while the former will not. This means I can be connected to freenode and my BitlBee server at the same time. To send commands to a specific server, execute the following in the status window:

/window server <connection_name>

Read the quickstart guide if you wish; it’s fairly comprehensive, and will guide you through the rest of the setup process. If you are impatient, keep following along here to get started quickly, then you can head back to the quickstart guide to read the rest, as I’m not going to cover every feature (groupchats, etc).

Third step: Setup your account with the BitlBee server.

In the control channel (&bitlbee), execute the following (do the same for all following commands):

register <password_here>

BitlBee will associate this password with your current nick. Then, when you connect in the future, you just have to identify, either using the identify command or standard identification methods for IRC, and you will have access to your accounts.

Fourth step: Setup your IM accounts.

account add <protocol> <username> <password>

To set SSL (find the account number with “account list”):

account set <account_num>/ssl true

To force TLS (the default is try, which falls back to plaintext if not available):

account set <account_num>/tls true

Some examples:

AIM:

account add oscar my_screenname my_password

Google Talk:

account add jabber my_username@gmail.com my_password
account set <account_num>/tls true

Google Talk (for Google Apps, e.g. most college campuses):

account add jabber my_username@some_domain.example.com my_password
account set <account_num>/tls true
account set <account_num/server talk.google.com

Facebook:

account add jabber my_facebook_username@chat.facebook.com

Note that Facebook does NOT support encryption, while Google Talk requires it. This means all of your chats to Facebook will be sent in plaintext, which allows snoopers to listen in on your conversation, especially if you use an unencrypted wireless access point. (Note that the in-browser chat client also runs over HTTP, so the same is true.) However, your password is encrypted using a DIGEST-MD5 method prior to being sent over the connection to Facebook, so your password is fairly secure.

After you have setup your accounts and account settings, save:

save

Fifth step: Logging in to your accounts.

By default, BitlBee will connect to all accounts that have the auto_connect account property set to 1. However, to get started now, do the following:

account on

Sixth step: Making the channel nicks better.

Notice that, by default, BitlBee will use a buddy’s username or handle as their nick in the channel. If, like me, you have aliases set up on the server, this is rather annoying. In the case of Facebook, this is especially annoying as Facebook Chat does not actually use the usernames of your friends. Instead, it uses negative numbers. Well isn’t that helpful. Thankfully, BitlBee will let us change this behavior (added in version 1.2.5):

account set <account_num>/nick_source full_name
save
account off <account_num>
account on <account_num>

Instead of using full_name, you can also use first_name.

Seventh step: Chatting.

To chat with a user, simply address them in the control channel “username: Hey, I’m using BitlBee” or query them “/q username”. BitlBee will remember which method you use to talk to the user, so the response will come back to the same window. The default for incoming messages starting a conversation can also be set (“set private true/false”).

Final step: Go read the documentation.

As I said, BitlBee can do much more than this quick guide shows. Away and status messages, adding or removing users, blocking users, renaming users, group chats, buddy list interaction, typing notices, and simulating a netsplit are just some of the features I did not cover. BitlBee is a pretty powerful piece of software, and I’m glad that someone pointed it out to me.

Motorola Droid

Mon, 17 May 2010 00:00:00 GMT>

My first cell phone was the Motorola e815, one of the first 3G-enabled phones on the market. It was a great little phone that could get a signal in a canyon in the middle of nowhere, far from where Verizon said it should. Before Verizon killed the program, it also gave me 3G Internet access at the expense of my minutes via a bluetooth connection to my laptop.

For Christmas and my birthday this past year, I got a new phone: a Motorola Droid, which runs Android. In some ways it is a step back, but in even more ways it is a huge leap forward. The step back is of course battery life; it seems I am charging it every 20 seconds. The huge leap forward is the number of features it offers, of course. Web browsing, Google Voice integration (one of my favorite features), email at your fingertips, and full-featured navigation complete with street view and live traffic are just some of the main features. Those are the features covered in numerous reviews, so I’m going to sail right over them and skip to what makes this phone special.

First though, I want to differentiate this phone from that “other” popular phone, the iPhone. I wanted the original iPhone when it came out. There, I admitted it: I used to like the iPhone. However, Android is much much better for someone like me, a developer. Android is open. The iPhone is a classic case of Apple control, a walled garden. Apple has rejected applications because they might possibly “confuse the user.” On Android, there are so many applications that may not be the most intuitive, but are awesome to the point you wondered how you lived without them. Can my phone be a FTP server? Check. SSH server? Check. SSH client? Check. VNC client? Check. GPS device with GPX export? Check (it also syncs with Google Maps). A barcode scanner? Check, complete with barcode generation for sharing with other phones. Translation tool? Check. Gaming platform? Check, and I can even use a wiimote to control the games. The phone even comes from Verizon loaded with a proxy that you can use via USB, and with some playing around you can even make it a wireless access point via Wifi or Bluetooth. The iPhone can of course do many of these things too, but for every story where I hear of Apple blocking some innovative application for some obscure reason, I find that my Droid lets me do whatever Apple will not. Oh yeah, and the Droid has a keyboard. After experiencing the disaster in GUI design that is the N800, I decided that a physical keyboard is a prerequisite for almost any mobile computing device I purchase. Indeed, after using the iPhone for the first time, I am extremely happy the Droid has a keyboard.

Let’s take a look at some of these features in more detail. Note, many of these features require installation of applications from the Android Market.

HTTP Proxy – The phone comes loaded with a proxy all ready to go. Just install the Android developer tools on your desktop or laptop, and you have port forwarding between your computer and your phone. The same developer tools also give you shell access to your phone, no additional software installation on the phone required. Install Privoxy on your phone, and your phone is now an HTTP proxy accessible from your computer.
Google Goggles – Google Goggles is one of those magical Google labs products. Take a picture of text, and it scans it for you, translating if necessary. Take a picture of a landmark, and it recognizes it. Take a picture of a logo, bookcover, or movie poster, and it searches for information about that graphic. Take a picture of a business card, and it offers to add the person’s contact information to your address book (which in my case then syncs with Gmail and my desktop email client’s address book). It isn’t perfect, but what it already does is pretty amazing. For example, I was sitting in a ski lodge at Howelsen Hill, home of the US Ski Team (Jumping), surrounded by the flags of the various countries of the Olympics, and I wanted to know to which country a particular flag belonged. Google Goggles not only found the right country, but it linked me to the Wikipedia article about the country so I could read more about it.
Games with a Wiimote – Who said gaming for phones was restricted to onscreen controls? The Droid has an accelerometer built-in, as well as a D-Pad and a multitude of buttons for gaming. But the most fun (and probably battery-taxing) feature comes with the help of a Wiimote and the WiimoteControl application. As the Wiimote connects via bluetooth, and the phone has a bluetooth radio, the two can connect to each other. WiimoteControl makes the Wiimote look just like another input device, available for use by every application on the phone. Combine this with one of the popular games that support input customization, and the Wiimote turns the Droid into a gaming device full of fun. I do not play games much myself, so this is perfect to fill the occasional car ride on vacation, as I lack any other kind of portable gaming device.
SSH Client – I realize most people do not want a phone so they can use it as an SSH Client. Most people probably do not even know what SSH, let alone why they would want it. That doesn’t stop the Droid from having an awesome shell client, ConnectBot. This lets me connect to my server or desktop from anywhere I have cell service, which is just about anywhere. I run irssi on my server inside a GNU Screen session, so this lets me keep up with the IRC chatter from anywhere. For those that want shell access to their local phone as well, ConnectBot allows you to open a local shell.
FTP Server – The Droid supports local file access just by plugging the phone into the computer. But who wants to play with cables just to transfer a single picture? Enter SwiFTP, an FTP server for Android. Fire up the application, start the server, and connect from any FTP client to transfer files. It is not as fast as a USB connection, but it is far more convenient.
GPS – For awhile now, I have wanted a handheld GPS device for hiking, biking, skiing, etc. However, I usually could not justify the benefits of a GPS based on the cost of the devices on the market. However, now that I have my Droid, I no longer need a GPS. Google My Tracks, another Google Labs product, records GPS tracks. It records your location at various, configurable time intervals, allowing export via standard GPX files or upload to Google Maps. The application also shows graphs of speed and elevation vs time, various statistics such as max speed, and a map overlay of the route taken. It’s perfect for telling me that I can take a ski run 1.2 miles long at 99.6 km/h, or showing the maximum gradient I took while riding my mountain bike. Want more information about the GPS satellites themselves? GPS Status tells you how many satellites are in view, in addition to accuracy information and a radar map showing marked waypoints. Finally, I should note that the camera application can record your location when taking a picture, which is pretty neat when the data is overlayed on a map after a trip. The usually gets a fix before I can frame the shot, so it’s fast too.
Barcode Scanner – The Barcode Scanner and Google Shopper applications have to be my most unexpected use of my phone. Picture this: you are in your bookstore wondering if the store is charging far too much for a book. You whip out your phone, take a picture of the barcode on the book, and your phone returns a list of prices from various online retailers. These applications, which work well together, are quite handy. In addition, URL and contact sharing is easy. Just take a picture of a barcode, which can even be generated by another phone, and the application will recognize the type and offers the appropriate actions.
Google Sky Map – This application has to be the most innovative use of my phone so far. Combine the phone’s GPS, the phone’s accelerometer, and a connection to a catalog of astronomy data, and you have Google Sky Map. Start up the application, point the phone at the night sky, and watch as constellations, stars, and planets are identified on the screen.

These are just some of the reasons my Motorola Droid, and Android itself, are awesome. This isn’t to say my Droid doesn’t have its faults as well. It is not close to perfect. For example, when the phone is done charging, it immediately starts to drain the battery and refuses to charge until the power source is killed and then reconnected. Google Voice sometimes decides to not sync properly, resulting in issues. For some reason, the phone has both a Gmail client and an email client, two separate applications with similar feature sets (except for the fact the email client cannot move a message from one IMAP folder to another). The same is true of the Corporate Calendar application and the Calendar application; the former connects to Exchange while the latter connects to Google Calendar and Google Tasks. Android fragmentation is indeed a problem as well. Many different phones run slightly different versions of Android, and carriers are slow to upgrade their devices, resulting in numerous devices unable to run the latest applications. Hopefully these issues are solved in the future.

My phone is awesome; Android is awesome. Hopefully they’ll get even better in the future.

Testing Whether an Integer is a Power of 2

Thu, 13 May 2010 00:00:00 GMT>

By using the & (logical and) operator, we can easily (and quickly!) test whether an integer is a power of 2.

In C:

int isPowerOfTwo(unsigned int x)
{
   return (x != 0) && !(x & (x - 1));
}

This works because an integer that is a power of two, x, is represented by a single 1 bit, with the other bits being 0. The same bit in x-1 will always be 0 because of the subtraction. Thus, when the two are anded together, the result will always be 0.

For example:

x = 1: x = 0001, x-1 = 0000, x & x-1 = 0001 & 0000 = 0000
x = 2: x = 0010, x-1 = 0001, x & x-1 = 0010 & 0001 = 0000
x = 4: x = 0100, x-1 = 0011, x & x-1 = 0100 & 0011 = 0000
x = 8: x = 1000, x-1 = 0111, x & x-1 = 1000 & 0111 = 0000

But if x is not a power of two, the result is not 0:

y = 3: y = 0011, y-1 = 0010, y & y-1 = 0011 & 0010 = 0010
y = 5: y = 0101, y-1 = 0100, y & y-1 = 0101 & 0100 = 0100

Update:
I have come across another way to quickly test if an integer is a power of two.

In C:

int isPowerOfTwo(unsigned int x)
{
return ((x != 0) && ((x & (~x + 1)) == x));
}

See if you can figure this one out for yourself.

Hello World

Wed, 12 May 2010 00:00:00 GMT>

Hello and welcome to my blog.

Vargoville

Fixing Old Themes for Enlightenment 17

Finding and Eliminating Duplicated Files

Hello World

Lenovo T420 Internal Microphone and Linux

Copying Chromium/Google Chrome Search Engines

Backround

Getting Started

Exporting the Data

Importing the Data

Conclusion

Arduino Installation Notes

Introduction to awk

Common Usage

How This Works

Special Variables

Another Example

Other Patterns

More on Patterns

Further Information

The Bluetooth Blues: Getting a Linux PC to use a GPS on an Android Device

Step 0: Figure out the MAC address of the bluetooth interface on your computer and phone

Step 1: Pairing the devices

Step 2: Setting up the GPS

Step 3: Setting up RFCOMM

Step 4: Configuring GPSd

Step 5: Test it out.

Troubleshooting A few useful tools for debugging:

Dynamic Ticks for Operating Systems

Backgrounds

New Blog Engine

Functional Programming with PHP

BitlBee - Changing the Way I IM

Motorola Droid

Testing Whether an Integer is a Power of 2

Hello World

Troubleshooting
A few useful tools for debugging: