Not being able to google information required to complete the job was a little frustrating (not that all the information I needed was readily available on the internet, but at least one time it would be useful). The task at hand involved programming some JNIs for android and making them render some content on a bitmap to be presented on screen. Though task.

The whole situation was looking badly, but I decided to go ahead and do it and I was able to successfully get it done. The whole experience was one of learning and confirming some ideas on my head for some time:

• Being disconnected while programming requires you have to figure out a lot of stuff on your own, with sharp focus. I only had a paper copy of the JNI book on my backpack to do research, and that helped me up to some point. Afterwards, I was on my own.
• Not being able to communicate with your peers via instant messaging or email means that you have to think alone. At the office, it’s easy to go to a more experienced peer and ask him to help figure out what’s going on. While disconnected, I needed to pay more attention to what was happening to solve my own issues.
• At the very end I was trying to figure out why the screen rendering was not happening. Everything was OK in the backend, but the screen was pitch black. I spend two hours trying to solve this issue with different approaches. So, I decided to enjoy my time a little. At one moment, some idea popped on my mind that helped me figure out the problem, in one of that famous “shower moments”. If I had spent all the time in between in the pursuit of an answer, I would have not found it, because I was looking at the wrong place. Letting the answer come to me was a better solution to my problem.

def fact(n):
    if n <= 1: return 1
    return n * fact(n - 1)
fact(90000)

There’s one bike item in my life projects, which is to ride an Audax. So I’ll spend the next few months preparing for it physically and creating a gadget that I have in my mind to make the training trackable.

Yep, that’s something worth trying.

I work with come software that takes about 10 minutes to compile, and what I do when I have nothing else to do during the compilation is to read Hacker News, where I usually waste more time than it’s allowed for good productivity. NOT ANYMORE!

Now my compilation line has and extra command that pops-up a windows saying that the compilation has come to an end. Pop-ups are provided by zenity on Ubuntu. You can look for similar solutions on your platform. I’m sure they’re available.

My compilation command looks like this:

make && zenity --info --text "Compilation Finished" || zenity --error --text "Compilation Failed"

carefully look at the object code to minimize transistor state transition – where all the power consumption occurs.

I think this is a bunch of bullshit for two reasons. But first, allow to retort a bit. Low-power-consumption software is applicable in any device that is running on a battery (e.g. your phone), but the concept that’s being taught is completely overstated.

My two reasons:

• processors like the ARM Cortex A8 on your iPhone 4 are superscalar. Which mean that they reorder the instructions in execution time to accelerate the overall program execution. Which makes the argument invalid. Looking at your object code will only be a waste of time.
• there are better ways to reduce power consumption on devices. One of them is reducing the power dissipation in the transistor state transition. (Or maybe using a black-hole as a cooling device .)

You can argue that it may apply to smaller devices with simpler architectures. Surely I agree, but still who looks at object code these days? Let the compiler do hard work. And how many of the students will really work on these kind of computers? Not many.

Also, in phones the major power consumption doesn’t happen in the processor. The radios (GSM, 3G, GPS, wifi and Bluetooth) and the screen are the greatest wasters. Why focus on bits, when the phone screen alone wastes more than 90% of the phone’s battery? Minimize the time that screen and radios are on, and you will be saving many more watts (and time) than the power saved by perfectly aligned bits.

Another professor says that we should focus in reducing disc spins. There are no discs spins since the invention of flash drives. QED.

The same professor says that reducing the algorithmic complexity of the program will reduce the power consumption. With this I agree. It seems the single improvement in software engineering that will have the largest impact in devices’ power consumption. Reducing an O(n) algorithm to O(log(n)) will reduce the power consumption by one order of magnitude. That’s way more saving than the OCD behavior of aligning bits.

TLDR: carefully looking at bits to reduce power consumption will only work if the processor is not superscalar. Reducing the power consumption on transistors, screens and radios, and reducing the algorithmic complexity of your software are a better way of controlling power consumption, but don’t OCD  yourself over this.

If you have arguments against my case, the comment box is at your service

I was trying to run some Android tests in an application that has several activities running in separate processes. If you have ever tried to do such thing, you know that it isn’t very straightfoward. It complains that it can’t instrument an activity whose intent was resolved in another process. Bummer!

I’ve spent some time thinking how to test this, and I figured a way. The activities that where put into testing didn’t need to run in separate processes when running alone, so simply extending the target activity and declaring it on the AndroidManifest without the android:process attribute made possible to run the automated tests on this new activity. One caveat: this must be done in the application package, not in the application’s test package. So this will add a little bit of turmoil to your application.

The possibility of running your application on the main thread may or may not be your case. If it isn’t, then you’ll have to find your own way. In this case, there’s one thing I would like to ask: if, by any chance, you solve this problem without the dirty trick, please leave a comment on this article. It may help people in the future, and I’ll gladly take links, if that’s the case.

You can get the sample code on github (as soon as I post it there).

Zooomr : android, tests

Installation

The first thing I’ve done was resizing the Windows Vista partition to make space to Ubuntu. This can be done using the tutorial on How-To geek: Resize a Partition for Free in Windows 7 or Vista. I still need Windows since the corporate world is plagued with this beast. If you don’t need to use it, you can get rid of it.

Next, you should download and burn the Ubuntu Server Edition 10.10 and reboot your computer with the disk on the tray (or the pen drive connected, if you choose to install with a pen drive.) After selecting the installation language, hit F6 and select nomodeset. Then proceed the installation. I chose not to use guided partitioning, and make the partition setup myself.

When the install process is completed, reboot your system into Ubuntu and login. To install the Ubuntu Desktop, issue the following commands:

sudo apt-get update && sudo apt-get install ubuntu-desktop

Now go get a mug of coffee. The desktop install will take a while.

Installing and configuring the NVidia Quadro FX 380m driver

Don’t reboot the computer yet. First you need to install and configure your video driver. To do this, run the following command:

sudo apt-get install nvidia-glx-180 && sudo nvidia-xconfig

Networking

I use network-manager to auto-configure my networks. The default Ubuntu Server installation comes without this tool, and the network is configured using the old debian scripts. To disable this, you’ll need to edit the configuration file, /etc/network/interfaces, commenting all lines except

auto lo
iface lo inet loopback

which means that your file will look something like this:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
#auto eth0
#iface eth0 inet dhcp

This should do the trick.

Now reboot your notebook and you should have the desktop installed and running.

Good luck, and YMMV.