Acer Aspire One Cloudbook 14 Laptop

My wife's old Dell XPS 15 was dying a slow death, and making a lot of fan noise while it did so. After taking the laptop apart and cleaning the fan with no change, I finally decided it was time for a new laptop.

It seems that over time all laptops eventually start making noise – either from a fan or the hard drive. With the advent of SSD's (solid sate drives), the hard drive is no longer a concern, but fan noise is still a ticking time-bomb in my experience. So this time I decided to get her one with no moving parts.

The other common issue I've had with laptops, is having the battery life go to hell pretty quickly. I think this is exasperated due to the practice of leaving most laptops in my house (I have a few) plugged in for long periods of time so the battery does not go through frequent drain/charge cycles. Having a longer batter life will help this as my wife will be more likely to leave it unplugged more frequently.

And my final criteria is that the laptop must run well with Ubuntu. I've had my wife using Ubuntu for many years now and have no reason or desire to move her back to Windows.

After doing some internet searches and reading some reviews I found the Acer Aspire One Cloudbook 14 Laptop. And while it was a minimal laptop to be sure (only 2GB RAM and 32GB eMMC drive), it was good enough for my wife's needs. The main selling points of having no moving parts, a 12 hour battery life (that really is about 12 hours), and a price tag of about $120 on sale, made it an easy choice for me.

I liked it so much that I bought one for myself to use for long flights and any time I need to go long periods w/o a power supply. It really just has barely enough RAM to run one or two apps at once, but it's good enough for running Emacs and a browser which is what I spend most of my time using.

To install Ubuntu I followed Nicolas Bernaerts' excellent instructions. And while a 32GB drive is enough for my wife, I wanted a larger drive, so I bought a 128GB USB drive and followed these instructions on mounting it as my home drive. It just stays plugged in all the time. I probably could have just put the entire installation on it and booted from the USB. Maybe I'll try that at a later date as then my setup becomes a lot more portable if my laptop should die on me.

My only complaint about the laptop is with its keyboard. It is very stiff and I find it difficult to consistently have key presses register. I'm hoping this will ease up over time. Also, I would be happier with 4GB of RAM as the swap partition gets used a lot.

People think computers will keep them from making mistakes. They're wrong. With computers you make mistakes faster.

– Adam Osborne

How to Root a Samsung Fascinate Android Phone with Ubuntu Linux

These are the steps I took to root my Samsung Fascinate. Rooting gives the following abilities and more:

• Install custom ROMs with ROM Manager (I have not tried this yet)
• Backup your phone with Titanium Backup
• Block unwanted calls and messages with Mr. Number Call Block
• Give other applications root access if needed
• Have total control of your phone
• Remove Bing and replace it with Google

This article assumes you have already installed the Android SDK. I also assume that you have the platform-tools directory as part of your path. If not, you will need to specify the full path whenever you see the adb command used, like ~/android-sdk/platform-tools/adb.

The first step is to get your computer to recognize the phone. I followed the instructions on the Android developer site that explain how to do it. I'll summarize the steps for Ubuntu.

First make sure your phone is setup for development by performing the following steps:

• From the Home screen, press the Menu button, then Settings
• Select Applications
• Make sure 'Unknown sources' is checked
• Select Development
• Make sure 'USB debugging' and 'Allow mock locations' are checked

Connect your phone to the computer using the USB cable that came with the phone. Now your phone should appear in the list of usb devices:

lsusb

...
Bus 002 Device 006: ID 04e8:681c Samsung Electronics Co., Ltd Galaxy Portal/Spica Android Phone
...

As root, edit /etc/udev/rules.d/51-android.rules so it looks like:

SUBSYSTEM=="usb", SYSFS{idVendor}=="04e8", MODE="0666"

Replace "04e8" with the vendor id found in your lsusb output from the previous step (it's the first four characters after ID).

Now set the permissions on the file and restart udev to enable it.

sudo chmod a+r /etc/udev/rules.d/51-android.rules
sudo /etc/init.d/udev restart

Now run the adb command and check for devices:

adb devices

List of devices attached
I500cf846986    device

You should see your device listed. If you do not try restarting adb with:

sudo adb kill-server
sudo adb start-server

Assuming you have made it this far and adb can see your device, we can continue with the rooting process. The following instructions were taken from this Newbie Guide to Rooting the Fascinate.

Download and unzip root.zip into a new directory. You should have the following files:

busybox
rageagainstthecage-arm5.bin
su
Superuser.apk

Push the rageagainstthecage-arm5.bin file over to the phone:

adb push rageagainstthecage-arm5.bin /data/local/tmp/rageagainstthecage-arm5.bin

Shell into the phone and setup the next step:

adb shell
cd /data/local/tmp
chmod 0755 rageagainstthecage-arm5.bin

After the next step there will be a pause (for a few seconds) then you will be returned to the shell prompt. Then wait another 20 seconds or longer and you should be kicked out of the adb shell. If your phone locks up, nothing bad should happen, just try forcing a reboot by pressing and holding the power button, or removing the battery for a few seconds.

./rageagainstthecage-arm5.bin

You should see the following then the command prompt again.

[*] CVE-2010-EASY Android local root exploit (C) 2010 by 743C

[*] checking NPROC limit ...
[+] RLIMIT_NPROC={3712, 3712}
[*] Searching for adb ...
[+] Found adb as PID 2200
[*] Spawning children. Dont type anything and wait for reset!
[*]
[*] If you like what we are doing you can send us PayPal money to
[*] 7-4-3-C@web.de so we can compensate time, effort and HW costs.
[*] If you are a company and feel like you profit from our work,
[*] we also accept donations > 1000 USD!
[*]
[*] adb connection will be reset. restart adb server on desktop and re-login.

After waiting until you are kicked out of the shell, restart the adb server and re-login:

sudo adb kill-server
sudo adb start-server
adb shell

You should now be at a root (pound symbol) prompt. Exit the shell:

exit

Now to make the root permanent do the following:

adb push su /data/local/tmp/su
adb push busybox /data/local/tmp/busybox
adb shell
mount -t rfs -o remount,rw /dev/block/stl9 /system
cat /data/local/tmp/su > /system/xbin/su
cat /data/local/tmp/busybox > /system/xbin/busybox
chmod 4755 /system/xbin/su
chmod 4755 /system/xbin/busybox
exit

Install the Android application that controls root access:

adb install Superuser.apk

After it installs you will see Success on your screen and the connection will hang. Press Ctrl-C and reboot your phone. You should now have permanent root.

The Library of Congress has specifically exempted rooting from the DMCA (Digital Millennium Copyright Act)… This means that it is now 100 percent legal to root your Android phone (or jailbreak your iPhone) whenever you want without fear of legal action taken against you.

– David Wasserman, Android Phone Geek, "Rooting Your Phone Now 100% Legal", 2010-07-26

How to Install Android on Ubuntu Linux

Once again I've decided that I want to take a look at programming for the Android platform. One of the first things to do is to get an Android emulator and a programming environment setup. After searching around a few different sites to get the instructions I've compiled the steps to get an emulator working under Ubuntu Linux here.

Android SDK Manager

I followed the steps on the android site. Using the command line in Ubuntu, here are the steps to follow:

Install OpenJDK:

sudo apt-get install openjdk-6-jre

If you are running a 64-bit OS, then install the needed 32-bit libs:

sudo apt-get install ia32-libs

Download the latest SDK from the Android site (which, as I write this, is android-sdk_r07-linux_x86.tgz).

Uncompress the tarball into your home directory and rename it:

tar xfvz android-sdk_r07-linux_x86.tgz
mv android-sdk-linux_x86 android-sdk

Here are all of the above steps combined:

sudo apt-get -y install openjdk-6-jre
uname -m | grep -q "\(x86_64\|ia64\)" && sudo apt-get -y install ia32-libs
cd
wget http://dl.google.com/android/android-sdk_r07-linux_x86.tgz
tar xfvz android-sdk_r07-linux_x86.tgz
[ -e android-sdk ] && mv android-sdk android-sdk.$(date +%y%m%d)
mv android-sdk-linux_x86 android-sdk

Optionally you may add the Android tools directories to your PATH by adding the following to your .bashrc file:

export PATH=${PATH}:${HOME}/android-sdk/tools:${HOME}/android-sdk/platform-tools

Now run the Android SDK and AVD Manager via:

~/android-sdk/tools/android

Or, if you are running GNOME, make a custom application launcher, by either right-clicking a panel and selecting Add to panel… then adding a Custom Application Launcher, or by right-clicking the Main Menu and selecting Edit Menus then select Programming then New Item. The custom application launcher should have the following properties (substitute your $HOME directory for /home/USERNAME):

• Type: Application
• Name: Android SDK Manager
• Command: /home/USERNAME/android-sdk/tools/android
• Icon: gnome-robots.png

Now configure the Android Manager:

• Click on Settings, then check Force https://… sources to be fetched using http://…
• Click on Installed Packages, then Update All…, then Accept All followed by Install on the window that comes up; it will take a while to download and install everything; when it finishes, close the window (and the application if prompted to do so)
• Redo the above step until no more updates can be performed
• Click on Virtual Devices, then New…, give it a Name and select a version of Android for Target, then optionally add an SD Card and Hardware as desired, finally click Create AVD

You can now run this virtual android image by clicking the Start… button. Or from the command line (replacing NAME with the name of the virtual you created):

~/android-sdk/tools/emulator @NAME

You can also create a custom application launcher with that command.

The next time you want to make sure your android installation is updated you can run:

~/android-sdk/tools/android update sdk

#+BEGIN_COMMENT

Android on VirtualBox

I followed the steps this article. Using the command line in Ubuntu, here are the steps to follow:

First, if you do not already have VirtualBox installed, you can install the open source edition with the following command:

sudo apt-get install virtualbox-ose

Now, under your Accessories menu you should see the VirtualBox OSE launcher.

#+END_COMMENT

Eclipse IDE

Even though I prefer to code in Emacs whenever possible, the recommended method of programming for the Android platform is with the Eclipse IDE. So, I'm starting with that at least until I get more used to Android programming.

At first I tried to install Eclipse with apt-get like so:

sudo apt-get install eclipse

However, I could not get the Android Development Tools to install with that version of Eclipse (Galileo v3.5.2). So, like many others have, I decided to use the latest version from their web site. I downloaded the 64-bit Eclipse Classic (Helios v3.6.1) tarball from their download page. You should download the correct version for your architecture and uncompress it in your home directory.

tar zxvf eclipse-SDK-3.6.1-linux-gtk-x86_64.tar.gz

You might want to create a custom application launcher for it with these settings:

• Type: Application
• Name: Eclipse
• Command: /home/USERNAME/eclipse/eclipse
• Icon: /home/USERNAME/eclipse/icon.xpm

Now launch Eclipse. Then select Install New Software from the Help menu and add the following sites:

• Google Eclipse Plugin: http://dl.google.com/eclipse/plugin/3.5
• Android Development Tools: https://dl-ssl.google.com/android/eclipse/

Install everything from each of them in the above order.

After that finishes, select Preferences from the Window menu. Select Android on the left and set the SDK Location to /home/USERNAME/android-sdk or wherever you installed the Android SDK. When you apply it you should see a list of Android target versions. OK the change.

Now when you create a new project, you can pick Android as a type.

James DeBragga [Windows Consumer Product Manager]: Android is "free like a puppy".

spark: "Free like a puppy" is certainly much, much better than an atrociously priced and uncontrollably incontinent, rabies-infected mad hound.

ASUS Eee Sub-Notebook PC

ASUS makes this pretty cool looking sub-notebook PC called Eee PC. Even though this computer has been out for a while, I just recently learned of its existence. It seems like a good competitor to the OLPC.

It has a 900MHz Intel CPU, either 256MB, 512MB, or 1GB of DDR2 RAM, and either a 2GB, 4GB, or 8GB flash drive depending on the model. They all have a 7 inch screen with 800x480 resolution and built in 802.11g wireless. With no moving parts for the hard disk, this PC should be very quiet.

It comes installed with a customized version of Xandros Linux which can be updated from Debian repositories. It can also run Windows XP, which can be purchased for $40. The default install boots in (a very impressive by today's standards) 15 seconds.

Even though the price range was supposed to be in the $200 to $300 range, it seems that the middle range models are selling for around $400 at Amazon and Best Buy.

WikiPedia has more information and here are some reviews that go into more details about the device:

• Notebook Review
• Hot Hardware

I don't know half of you half as well as I should like; and I like less than half of you half as well as you deserve.

– Bilbo Baggins [J.R.R. Tolkien, "The Fellowship of the Ring"]

Basics of the Unix Philosophy

Even though the title of this entry is Unix Philosophy, every programmer needs to read this if they are not familiar with it already. A while back I read a great book called The Art of UNIX Programming which may be read free online or purchased in paperback form. While the whole book is good and relevant for any programmer, one section really stood out in my mind.

In chapter 1 there is a section called Basics of the Unix Philosophy that lists a few different versions of programming rules by different authors. I feel that each of the lists are valid and should be considered by any software developer.

The first one is from "Doug McIlroy, the inventor of Unix pipes and one of the founders of the Unix tradition": [1]

1. Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new features.
2. Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.
3. Design and build software, even operating systems, to be tried early, ideally within weeks. Don't hesitate to throw away the clumsy parts and rebuild them.
4. Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you've finished using them.

These rules were also summarized as: [2]

This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.

The next list of rules is from "Rob Pike, who became one of the great masters of C": [3]

1. You can't tell where a program is going to spend its time. Bottlenecks occur in surprising places, so don't try to second guess and put in a speed hack until you've proven that's where the bottleneck is.
2. Measure. Don't tune for speed until you've measured, and even then don't unless one part of the code overwhelms the rest.
3. Fancy algorithms are slow when n is small, and n is usually small. Fancy algorithms have big constants. Until you know that n is frequently going to be big, don't get fancy. (Even if n does get big, use Rule 2 first.)
4. Fancy algorithms are buggier than simple ones, and they're much harder to implement. Use simple algorithms as well as simple data structures.
5. Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.
6. There is no Rule 6.

"Ken Thompson, the man who designed and implemented the first Unix" adds:

When in doubt, use brute force.

Finally, the author, Eric S. Raymond, offers the following rules: [4]

1. Rule of Modularity: Write simple parts connected by clean interfaces.
2. Rule of Clarity: Clarity is better than cleverness.
3. Rule of Composition: Design programs to be connected to other programs.
4. Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
5. Rule of Simplicity: Design for simplicity; add complexity only where you must.
6. Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
7. Rule of Transparency: Design for visibility to make inspection and debugging easier.
8. Rule of Robustness: Robustness is the child of transparency and simplicity.
9. Rule of Representation: Fold knowledge into data so program logic can be stupid and robust.
10. Rule of Least Surprise: In interface design, always do the least surprising thing.
11. Rule of Silence: When a program has nothing surprising to say, it should say nothing.
12. Rule of Repair: When you must fail, fail noisily and as soon as possible.
13. Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.
14. Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.
15. Rule of Optimization: Prototype before polishing. Get it working before you optimize it.
16. Rule of Diversity: Distrust all claims for "one true way".
17. Rule of Extensibility: Design for the future, because it will be here sooner than you think.

Even though all of the rules are important some of the ones that have helped me a lot when programming are: (1) modularize your code and (2) write clean obvious code, or if you can't, make sure you document it well.

Rules that I see a lot of commercial programs fail to adhere to are: (10) they don't do what you expect them to do (like forget your preferences every time you upgrade) and (11) annoy you with pop-up dialog boxes when everything is fine (Success! Press OK to continue.). These issues often occur in Windows applications, however, I'm now noticing some KDE/GNOME applications that do the same thing.

Unix is very simple, but it takes a genius to understand the simplicity.

– Dennis Ritchie

[1] The Bell System Technical Journal. Bell Laboratories. M. D. McIlroy, E. N. Pinson, and B. A. Unix Time-Sharing System. 1978. 57 (6,part2). p.1902.

[2] Peter H. Salus. A Quarter-Century of Unix. Addison-Wesley. 1994. ISBN 0-201-54777-5.

[3] Rob Pike. Notes on Programming in C.

[4] Eric Steven Raymond. The Art of Unix Programming. Addison-Wesley.

1. ISBN 0-131-42901-9. (ch1s6).