However, Amazon does not provide any specification on the exact method of throttling nor how long you can use full CPU utilization before the VM throttles.  I couldn’t find any info on this elsewhere, so I did some testing myself.

I wrote a short program that generates a desired amount of CPU load and measures the amount of CPU time it receives (in generic units).  I ran it on a 64-bit micro instance running Ubuntu Linux in the EU Ireland region for 10 minutes at varying CPU utilization, idling for 10 minutes between each test.  Below are graphs on the allotted CPU time for various load levels.

Micro instance 100% load

Micro instance 75% load

Micro instance 50% load

Micro instance 25% load

Micro instance 20% load

Micro instance 15% load

Micro instance 10% load

Full load throttling

One interesting question is how the throttling performs when the CPU is fully utilized, which may occur for example during a system upgrade.

In this case the throttling is rather binary; the VM either allows using the entire CPU, or throttles to about 11% of the full capacity.  You get about 10-13 seconds of full CPU power every 2-2.5 minutes, though this duty cycle varies somewhat.

Constant load level

Micro instance 10% / 15% / 20% load

Another interesting matter is how much constant load you can provide a micro instance without it throttling.  This plot shows the results for 10%, 15% and 20% load levels.  From this it’s evident that the 20% load already throttles occasionally, but 15% load does not seem to have significant throttling.

Therefore if your micro instance web server’s load is going above 15%, you’re in a danger zone.  Once the throttling starts, response times will spike and requests may start piling up.

This limit is also evident when summing up the total CPU time obtained during the 10 minute tests.  From 20% load to 100% load the program got approximately the same amount of CPU time during the test, but for 10% and 15% it utilized less processing time than was available from the VM.

Another result of this is that if you have to do long processing on a micro instance, it’s approximately the same whether you hog up all the CPU you get, or slow down the processing yourself.

Conclusions

Micro instances are well suited for uses where there is little constant load.  A constant load level of 15% can be sustained indefinitely without CPU throttling.  However, it’s good to remember that if you’re constantly using all of your allotted CPU time, you may be throttled very quickly in CPU-intensive bursts.

During throttling, the available CPU is between 10-50% of the normal peak power.  The higher the load, the more aggressive the throttling.  With full load, you only get full power for about 10 seconds every 2 minutes, and 11% CPU time otherwise.

For long CPU-intensive tasks (lasting several minutes) it doesn’t matter whether you use all the CPU you get or regulate it, the task will take as long to finish anyhow.

Keep in mind, these are results for a single micro instance type in a single region.  Amazon doesn’t specify that the rules are the same everywhere.  They may even change according to the time of day and other region activity.  YMMV.

During that time Gimp evolved fast.  I anticipated every next release, and each one seemed to get closer to the functional level of PhotoShop.  Somewhere around version 1.2 – at least from my perspective – the only major deficiencies were lack of 16-bit color and CMYK support.

But then the development slowed down.  Major releases have been coming out every 1-3 years, but I haven’t noticed much change between them.  16-bit support and CMYK would be supported by GEGL, the do-it-all graphics library of the next-generation Gimp.  GEGL’s first release was in 2000, and Gimp has yet to see 16-bit support.

For many years now I have considered the Gimp to be at a dead end.  I have the utmost respect for the people who have worked – and still work – on it, and I use Gimp regularly.  But it seemed that to pull the next big thing into Gimp was too large an undertaking for a volunteer project.

Gimp 2.8

When I upgraded to Linux Mint and launched Gimp, I was in for a surprise.  After four years of development (think about it – that’s when Obama was first elected) Gimp 2.8 had been released.

My first reaction was that of disgust.  I couldn’t do anything in it.  Saving files was a pain, and even the standard brushes had been removed.  After cursing about it a while, I started looking around for a reason why these stupid changes had been made.

Ctrl+E is the new Ctrl+S

I came across the article GIMP 2.8: understanding UI changes.  I recommend every Gimp user reads it.  It explains the rationale the changes have been made, and even offers a simple “fix” to change the behavior to what it was earlier.  Even though I was looking for such a solution, after reading the article I decided to leave it as it was.

In Gimp 2.8 you essentially can have two “save files” at the same time, one XCF file and one export file (PNG, JPG, etc).  Ctrl+S saves the XCF file, Ctrl+E saves the export file.  Using Ctrl+Shift will prompt for the file (Save as, Export as).  Once you get used to this, it does save a lot of hassle.  You can independently save the original XCF and export a file to be used outside.  When you do changes, you don’t have to worry about remembering to save both the exported and original versions.

Brush on the world

The other thing I was missing was the 1px, 3px, 5px, etc. brushes from the old Gimp versions.  After creating several new brushes for the purpose, I found out that these have been changed to a “Size” parameter in the tool options.  Now all brushes are resizable from one place.

One gripe still is that the size control slider is very hard to use precisely with small brushes.  I often work with brushes below 10px in size, and controlling the size using a linear slider than goes up to 1000px is not very user-friendly.  However, according to the UI change article, the tool options are going to have an overhaul soon as well.

Gimp 2.8 also has a number of other nice changes, such as expressions in entry fields (how often have you whipped open a calculator to divide a size?  Now just type “1234/3″), layer groups, and single window mode with image tabs.

The future

Looking past 2.8, the Gimp core has finally been ported to use GEGL by a hero effort of Øyvind Kolås and Mike Natterer.  This means that after waiting 15 years, Gimp 2.10 will finally have 16-bit color support.  Hooray!

The important question is, when will 2.10 be released?  Martin Nordholts has written about the problems in Gimp development cycles.  He states many of the problems that I have pondered and struggled with during OpenRocket development.  Gimp 2.10 development will utilize more feature branches, which are merged to the master branch only once they’re ready, so as not to hinder the release of other features.  This will hopefully allow more regular feature releases and more motivation for new developers to jump in.

I have yet to explore many of the features in 2.8, but for the first time in a long time I have a heightened sense of excitement about Gimp.  There is finally clear and undeniable improvement happening.

Finally, I have to restate my admiration at the people who have made Gimp a reality, from its early stages and through its troublesome times.  A huge thanks to you all, and hoping for a great 2.10 development cycle.  I am rooting for you once again!

• Configurability and ease of use
• Hardware support for a ThinkPad T430s
• Printer and display configuration
• Full disk encryption
• Running Windows in VirtualBox

Background

In the beginning there was Slackware*.  And the spirit of Slackware was emacs Makefile; make; make install.  Then came Debian, with vast repositories of software waiting to be installed.  Finally, there was Ubuntu, which combined the vastness of the repositories with “it just works”.

At least a few years ago.  I was originally really impressed in Ubuntu at how things just magically worked.  For the first time, I could plug in a printer and seconds later print out a document.  Specifically, I’ve been using XUbuntu, as it was easier to configure to my taste.

But as years passed, Ubuntu became stagnant.  Versions came and went, and nothing turned to the better.  On the contrary, quite often a new release would break something in my system, and I started postponing upgrading.  Therefore I started looking for an alternative.

Mate vs. Cinnamon

Many sites recommended Linux Mint as an alternative to Ubuntu.  When I got a new work laptop, I decided to try Mint out.  The problem was:  Mate or Cinnamon?

Both versions are provided equally on the site, without any proper description of the differences.  I wasn’t able to find any proper reviews either.  Therefore I loaded both on USB sticks and tested them out.

I initially tested – and finally decided to use – Cinnamon.  Cinnamon provides a nice amount of eye candy out of the box, while Mate doesn’t sport much.  My laptop has ample power, so there’s no reason not to have a bit of eye candy when opening and closing windows.  I also liked the “hot corner” desktop switcher.  When you hit the upper-left corner with your mouse, you’re presented with a view of your workspaces to switch to.  The menu also seemed a bit nicer, but that’s purely a matter of preference.

Cinnamon also seemed to sport a touch more of “it just works”.  One particular case was that after pairing my phone via Bluetooth, the dialog had an option to create a network connection using it.  It worked immediately – or at least after I figured out I have to enable it on my phone as well.

Cinnamon also had the option of switching desktops using edge flipping with the mouse.  This is a feature I’ve used and loved since the mid-90′s, and it’s hard to live without it anymore.  I couldn’t find such an option in Mate.  The problem was that the edge flip delay was fixed at ~2 seconds, which is waaay to long for my taste – I want the flip to be instantaneous.  After asking around without answer, I checked out the source code and there it was, hard-coded.  I added the option for configuring the delay and issued a pull request – hopefully the next version will have it built-in.

The bottom line is, you’ll be fine with either.  Test both, and see which one seems to tickle your fancy more.

Hardware support

The out-of-the-box experience was amazing.  Everything was automatically configured and just worked.  Sounds were fine, Bluetooth was functioning, brightness and volume controls functioned with a nice OSD showing, even the play/forward/back buttons work in Banshee.  The network options also list the built-in GSM modem, and while I haven’t been able to test it for the lack of a SIM card, it looks promising.

In contrast, in XUbuntu, I haven’t even seen the Bluetooth icon for several years, let alone been able to pair something it with…

But my joy was a bit premature.  While audio worked out-of-the-box, it soon stopped functioning.  Music players worked fine, but no audio to the speakers.  However, if I plugged in earphones it played fine.  I tried fiddling with the sound configuration to no avail.

After googling around I found instructions on a ‘model’ parameter needed for the sound driver on some systems.  The codec in my Thinkpad T430s is a Realtek ALC269VC, for which six different model parameters are listed.  After iterating a few times, I finally found that I needed to add the following line to /etc/modprobe.d/alsa-base.conf:

options snd-hda-intel model=laptop-dmic

So while everything looked good at first, some mojo was needed to fix the sound support after all.  I would have reported this to the ALSA team, but every link to their bug tracking system is dead. 

Displays and printers

When you plug an external display to the laptop, it’s detected within a few seconds and the desktop is spanned across both displays by default.  Hitting Fn+F7 switches between the standard laptop-only, monitor-only, extended display and cloned display modes.  There is no dialog for selecting the mode like in XUbuntu, but it works.  Resolutions and orientation can easily be configured from the settings, but mostly it just works directly.

Adding printers is also delightful.  From clicking the “Add printer” button it takes a whole two clicks to add a network printer.  USB printers are even easier:  plug it in and wait a few seconds.  But…

When the printer works, everything is great.  When it doesn’t, the configuration utility in Linux Mint is useless.  You cannot configure anything in it.  However after some exploration I found out that the printer configuration utility for Ubuntu was also installed, it just wasn’t present in the menus.  You need to launch is separately with “system-config-printer“.  Time for another tutorial.

Full disk encryption

Since this was my work machine, full disk encryption (FDE) was an important requirement.  The Linux Mint 14 installer unfortunately does not support FDE, though it does offer home-directory encryption.  However, a newer version of the installer does support FDE.  The development team just wasn’t satisfied with something in the new installer and it was dropped from the official release.

Thus, in order to get full disk encryption in Linux Mint 14, boot the desktop from a USB stick, then in a terminal run the following commands:

$ sudo apt-get remove ubiquity
$ sudo apt-get update
$ sudo apt-get install ubiquity
$ sudo ubiquity

This will upgrade the installer and then launch it, and you have the option for full disk encryption.

Note:  Originally I tried getting FDE to work following the Full Disk Encryption easy HOWTO instructions, but while I was able to complete all the steps, the system wouldn’t boot.  I wrote a new tutorial on the subject.

Running Windows 7 in VirtualBox

As my work machine, I occasionally have the need to use Windows.  (If for nothing else, to see if a web design works in IE.)  Therefore I wanted to set up a virtual Windows image within Linux.

Before installing Linux, I made a VMware image of the default Windows installation using VMware vCenter Converter.  However, I never needed it.  The preinstalled version contained a lot of junk software and drivers unnecessary in a virtualized environment, so I preferred to install Windows from scratch.

I preferred trying VirtualBox, as it’s open source.  I downloaded the proper ISO image, attached it to the new virtual image and booted it up.  Installation went smoothly, however the network connection didn’t work.  This was an issue with the version bundled with Linux Mint 14.  I upgraded to the latest version by adding

deb http://download.virtualbox.org/virtualbox/debian precise contrib

to the software sources and then using

sudo apt-get install virtualbox-4.2=4.2.4-81684~Ubuntu~precise

to force installation of the proper version.

After this the system worked fine and I was able to register the Windows copy using the license key provided with the laptop.  YMMV – take care when using your license key on an installation it wasn’t originally intended for.

I have had some problems with USB usage within the virtual system.  For example, when trying to install printer drivers in Windows, it did see the printer and try to install drivers (which Windows doesn’t support out-of-the-box), but when I manually tried to install the drivers, it couldn’t find the printer.  If USB usage from the virtual machine is important to you, I suggest to test it before committing to either VirtualBox or VMware.

Final thoughts / gripes

Linux Mint is an amazing distribution, which brings “it just works” to a new level and a very comfortable desktop to boot.  An interesting comparison is Linux Mint vs. Ubuntu in Google Trends.  While Ubuntu still trumps search volume 15-to-1 over Linux Mint, Ubuntu has been in decline for almost five years now, while Linux Mint is steadily gathering ground.

Nonetheless, there is still some polishing to do, some issues with hardware support and some gripes in the way:

• Full disk encryption was a bit of a pain to set up, but the good news is that it will probably be just a tick box away in the next installer.
• Sound driver caused some headache before I could figure how to get it working.
• The default printer setup doesn’t allow any configuration if the printer doesn’t work automatically.  You need to use a separate configuration utility for this purpose.
• The VirtualBox version that comes with Linux Mint 14 is outdated.
• While the Cinnamon desktop has excessive configurability in some areas, some places are minutely lacking.  In my case, configuring the workspace edge flip delay.

Who needs this much configurability for window effects?

Therefore I made my own, the No-nonsense ASCII chart.  It features:

• the hex code and character, easily legible from two meters away
• the decimal code, since this is occasionally needed
• only the control characters I have ever heard about  (NUL excluded – everyone knows that anyway)
• numbers and letters as a range, not individually printed out
• no nonsense

The chart is available in PDF and OpenDocument formats sized for A4 and Letter.  It’s licensed as CC-BY.  Customize as you will.

• ASCII chart (A4).pdf
• ASCII chart (A4).odt
• ASCII chart (Letter).pdf
• ASCII chart (Letter).odt

I recommend highlighting the most often used characters with a yellow highlighting pen (for web developers %, &, ? and =).

I was recently force-upgraded from my Nokia E7 because its USB-adapter broke off – again.  Long story short, I’m now adapting to life as a new Android user.

One of the most frustrating things immediately visible is how every application on the device believes it’s the center of the universe craving for attention.  Even though I haven’t installed many apps, my notification board is often crammed with stuff.  Right out of the box the phone had started beeping to the beat of incoming email, and it took me quite a while to figure out how to turn it off.

But tonight has been a nightmare.

At around 4 AM the phone bleeped.  I probably hardly stirred.  Then it bleeped again.  And again.  And again.  Slowly but surely it was wrenching me from sleep.

I tried ignoring it.  It was rare, maybe once every 5-10 minutes.  But each time I was just falling asleep, it bleeped again.  And again.  It was the electronic form of water torture.

Finally, after about an hour of futile resistance, I succumbed to the device’s will.  I opened it and found a Facebook notification.  I had just last evening installed the Facebook app, and figured it was causing the havoc – though I have only 1-2 friends abroad that should be awake at this hour.  I browsed through the app settings and turned notifications off, thinking I had slain the monster, and went back to sleep.  And then it bleeped again.

I recalled seeing some options for preventing notifications in the general settings, so I started scanning the menus.  I finally found the Blocking mode, turned it on, and configured it to block all notifications and the LED indicator.  For good measure I set the phone to vibration – I was afraid that muting it would mute the alarm I had set for the morning.  And then it vibrated.

At this point I was ready to drop the phone in a glass of water had it only fit in.

I was unsure was it a fluke.  As time passed I was starting to doubt myself that had I just dreamed it.  I turned sounds back on just in case there was some weird vibration alerts.  Time passed, and I was finally confident that the beast had been silenced and I tried frantically to get back to sleep.  And then it bleeped again.

Had this been my trusty Nokia, I would have turned it off an hour ago, confident in the fact that it will wake me up even if it’s turned off.  Hell, a Nokia phone will sound the alarm even if it has run out of battery during the night!  That’s bloody engineering!

Now I’m up, sure that I won’t get any more sleep tonight and knowing it will be a long day ahead.  I’m already panicking about what will happen tomorrow night, will the torture ensue again.  Maybe I have to go buy an alarm clock…

Post-mortem:

• I still have no idea what caused the bleeping during the night.  My best guess is that something in the charger or charging logic got screwed up and it starting notifying of a full battery every 5-10 minutes.
• I have had the phone multiple times emit varying beep noises, without any indication of what caused it.  It has a life of its own.
• A timed blocking mode seems to prevent unnecessary beeping during the night time.
• I verified that the Samsung will not wake you up if it’s turned off.  So much for conserving battery when you’re in a tight spot.  Similarly if you forget to plug the phone in when going to sleep and the battery runs out, you’re screwed.
• I found out that it will sound the alarm even if the device is set to mute.  I’m torn on this one – it would have saved me a night’s sleep, but I’d really want a button that ensures the phone will stay quiet no matter what.

However, I noticed that developers in our project were also writing duplicate step definitions, because they didn’t know the definition already existed with a different name.  We defined some scenario writing guidelines and nomenclature to be used, which helped somewhat.  Still, in the mass of test code it was often hard to find whether the step you needed already existed.

Things like Wally and Relish are great for converting the feature files into pretty documentation, but I couldn’t find anything similar for the step definitions themselves.  So I wrote my own:  cuke-steps

The script parses the step definition files and generates a single page document containing all the step definitions it finds, in a pretty-printed fashion.  By clicking on any definition you can see the file and row number where the definition is and the code for the step.

Originally I wrote the script to create Confluence wiki markup.  We have a Jenkins job run every night that generates the documentation and pushes it into our wiki using the Confluence Publisher Plugin.  I wrote a simple HTML outputter when publishing the script.  You can check out a sample output page generated from Alister Scott’s wmf-custom-page-object.

There’s still some work to be done, like prettifying the HTML output, creating a gem out of it and making it link directly to a source repo.  Any updates are appreciated.

In such circumstances it’s vital to have sufficient information included in the test report to understand what happened — otherwise you’re stuck trying to do an autopsy without a corpse.  When running Cucumber tests, we have found that a dump of the World is often extremely useful information.

The following piece of code does just that.  Whenever a Cucumber scenario fails, it dumps the contents of the World to the console:

After do |scenario|
  if scenario.failed?
    Kernel.puts "Scenario failed, world contents:"
    vars = self.instance_variables.select { |v| !v.to_s.include?("__") }
    vars.sort.each do |v|
      value = instance_variable_get(v)
      Kernel.puts "    #{v}=#{value}"
    end
  end
end

This iterates through the variables and writes them out one by one.  The select statement on line 4 filters out some Cucumber-specific variables stored in the World.

You can easily customize this to output elsewhere (we’ve found Kernel.puts to be the most reliable way to get the info out) or how to output certain data types.  For example, we use the rest_client gem extensively, so we’ve customized the hook to detect the response object and to output value.code, value.headers and value.body in that case.

The common first instinct is to write out the requests, payload and response expectations directly in the feature files.  After all, a major point of Cucumber and ATDD is specification by example.  The problem is that this results in very verbose descriptions that are hard to follow.

Consider the following example given in the json_spec gem:

Feature: User API
  Scenario: Index action includes full user JSON
    Given the following user exists:
      | id | first_name | last_name |
      | 1  | Steve      | Richert   |
    And I visit "/users/1.json"
    And I keep the JSON response as "USER_1"
    When I visit "/users.json"
    Then the JSON response should be:
      """
      [
        %{USER_1}
      ]
      """

Consider that for a moment.  Do you understand what’s happening in this use case?  Next imagine giving this over to your business owner for a feature review.

One of the goals of Cucumber and specification by example is to provide a common language between developers and business. The above example contains so much detail that the intent of the use case is lost.  The code reminds me a lot of an example that Aslak Hellesøy gave of using the web_steps.rb “training wheels” originally included in the Cucumber-Rails gem:

Scenario: Successful login
  Given a user "Aslak" with password "xyz"
  And I am on the login page
  And I fill in "User name" with "Aslak"
  And I fill in "Password" with "xyz"
  When I press "Log in"
  Then I should see "Welcome, Aslak"

This kind of detail should be abstracted out of the scenarios into higher-level steps and by use of page objects.  Such refactoring makes the tests read better and much less brittle.

So if you don’t write explicit operations, what do you write?  Consider what a business owner would write as individual requirements.  Describe the intent of the API, not the explicit details.

I came up with a quite nice format in which to write the API tests.  As an example of registration:

Scenario:  Successful registration
   When I perform registration with the required parameters
   Then the request should be successful
    And I should receive a valid access token

This describes the essential functionality of the API, without any of the gory details.  The corresponding step definitions could be something like:

When /^I perform registration with the required parameters$/ do
  # Populate request information
  @request_method = "POST"
  @request_url = "/rest/register"
  @request_body = {email: generateEmail, password: "pass123",
      terms_accepted: true}
  @successful_response_code = 201
  @error_response_code_email_reserved = 409
end

Then /^the request should be successful$/ do
  # Perform the request and assert the response code
  @response = RestApi.call(@request_method, @request_url,
      body: @request_body, expect: @successful_response_code)
end

Then /^I should receive a valid access token$/ do
  # ... test that the token in @response is valid
end

The interesting part is that the actions (“When”) store fields to the World, and only the post-condition “Then the request should be successful” performs the request.  This allows adding more directives that modify the request, resulting in very natural language:

Scenario:  Failed registration; email address in use
   When I perform registration with the required parameters
    But the email address is already reserved
   Then the request should fail due to email reserved

Here the step definition for “But the email address is already reserved” would either register the email address in @request_body.email or set the email address to something that is known to be reserved.  The corresponding “should fail” step expects the response code in @error_response_code_email_reserved.

This approach also abstracts the setting up the request parameters.  When we needed to make a change to the mandatory registration parameters, there was only one method that needed to be changed.

This structure has been a great success in our project.  Very often I’ve noticed that after having the feature file defined, it takes only 5-10 minutes to implement the steps.  There’s a lot of step reuse, and often you only need to write the request setup step, and possibly some custom post-condition steps.

One caveat of this approach is that the exact methods, URLs and parameter names are not presented in the feature file, and thus it does not function as documentation on its own.  We have a separate API document, and we’ve been considering moving the corresponding parts to the free-text description area in the feature files.  This would not be executable specification, but I think it’s an acceptable compromise.  I feel it more important to keep the scenarios succinct and readable, and thus more maintainable.