Microsoft Sculpt Ergonomic Ergonomic Desktop

Summary

I recently purchased the Microsoft Sculpt Ergonomic Desktop (link goes to keyboard only, I purchased with the mouse as well) and wanted to post my thoughts about it.

Background

Previously I had the wired keyboard from work and I really liked the keyboard a lot. It took some getting used to initially to break myself of a few muscle memory finger miscues but once I was over that (fairly quickly) I really appreciated the comfort of the keyboard on my wrists. I had heard good things about the wireless variant and asked Santa for this setup for Christmas in 2015.

microsoft ergonomic desktop

Keyboard

The keyboard has a feeling similar to a chiclet keyboard on any modern laptop, The key travel is very comfortable for each of the keys. Compared to say, my Dell XPS 13, the travel is probably double the distance which makes for a very comfortable typing experience. I LOVE that there is a switch to toggle between the function keys and multimedia keys, this makes it VERY convenient to switch between being able to do actions such as turn volume up/down and switch back to the Fn keys for debugging in IDEs (a very important detail if you are a programmer). For some, I’ve heard complaints about the Fn keys because they are half-size (as shown by the calculator key below), but for me this isn’t a big deal.

fn_key switch

The keyboard design is very modern looking and attractive (in my opinion) with the hollowed out area under the keyboard, much more so than the old wired variant I had which was a solid chunk of plastic. The plastic used for the wireless variant is a very premium feeling plastic, nothing about any of it feels cheap.

Mouse

The mouse is another story. I find the design very odd. It feels like I’m holding a baseball and it actually seems non-ergonomic to me. It doesn’t BOTHER me per-se because I’m not usually on the mouse nearly as much as the keyboard and I’ve never had issues with that hand/wrist, but the feel of the mouse is just a bit odd. I wouldn’t bother getting a different mouse and filling another USB slot for the connector (or using bluetooth to attach/detach to it), but it’s just a very weird feel to me. I’m pretty good as just dealing with things though, so for me this isn’t a deal breaker at all and I’m content to just live with it but it is something that did strike me as much less impressive versus the keyboard itself.

Bottom Line

For a programmer or anyone looking for a quality ergonomic keyboard I think Microsoft has nailed it yet again. They consistently deliver quality hardware and this is no exception. The desk space required for the keyboard is minimal (I rarely ever use a number pad which is a separate piece) and the look is all class.

If you are in the market for this keyboard, don’t hesitate – it’s a great piece.

Spring Boot and Docker

Summary

My toy angular/rest/spring project, HIIT (high intensity interval training), was something I wanted to package inside a docker container that could run on any machine, regardless of the presence of a JVM (especially Java8). I decided to try out the maven targets for packaging in a docker image – the result was VERY easy to do.

Background

Docker is something I’ve been slow to warm to. Historically my argument against it is that it was a quick-and-dirty solution (and I felt dirtier than it has to be) vs. standard package management like rpm/deb files. However, as I’ve played with Docker more seriously and thought about the troubles it digs people out of I’ve changed my tune. Pros that docker brings include not worrying about the dependencies that make your app run (i.e. the jvm) and being able to allow parameters/shared volumes to run multiple containers side-by-side with nearly zero overhead. When comparing this to standard package management this just isn’t possible.

My friend Blake also said something to me that really resonated, he said think of a docker image as your application’s “executable”. This instantly clicked with me. An executable is something that can be adjusted with command-line switches and is fully self contained (let’s not get too pedantic about dynamic libraries). It’s can be run many times and the switches give it a different ‘profile’. Once I started thinking about Docker images this way, it made me want to do more with Docker since it gives so much flexibility AND given its immutable nature (i.e. an image can never be changed, it is frozen in time just as git freezes a repo in time at each commit) Docker allows multiple instances to be running quite easily and unaware of each other.

How To

The Spring Blogs given a good Docker tutorial, all I did was apply the tutorial to my app.

First

First I made sure docker was installed on my machine (Ubuntu 15.10). This was as simple as running apt-get

sudo apt-get install docker

Second

After docker was installed I proceeded to add details to my pom.xml. You can see my branch here where I have the Dockerfile and changes in the pom.xml. There’s some other noise with my update of Spring Boot in the same branch, but generally speaking the interesting changes are

Dockerfile

FROM java:8
VOLUME /tmp
ADD com.basilio.hiit-0.0.1-SNAPSHOT.jar hiit.jar
RUN bash -c 'touch /hiit.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom", "-Dspring.profiles.active=hsqldb","-jar","/hiit.jar"]

pom.xml

..
<properties>
  <docker.image.prefix>jimbasilio</docker.image.prefix>
</properties>
..
<!-- Package as a docker image -->
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.2.3</version>
    <configuration>
        <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
        <dockerDirectory>src/main/docker</dockerDirectory>
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <directory>${project.build.directory}</directory>
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

The Dockerfile grabs the java:8 docker image from the docker repo, creates a shared volume in /tmp (where tomcat will write to), ensures the jarfile has a fresh datestamp on a docker rebuild, and declares the entrypoint to run (which means what switches I want the docker “exe” to automatically use). You can see I wanted to run in the -Dspring.profiles.active=hsqldb profile but I could have also passed parameters into docker to set the active profile.

Third

Now when I issue the docker image build via maven

[jim@galago~/projects/HIIT (master)]$ mvn package docker:build

you can see the docker image being built. From here I can see my image and then run my image and start my container

[jim@galago~/projects/HIIT (master)]$ sudo docker images
REPOSITORY                    TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
jimbasilio/com.basilio.hiit   latest              c3360feee95d        2 minutes ago       714.1 MB
java                          8                   d4849089125b        3 weeks ago         642 MB
[jim@galago~/projects/HIIT (master)]$ sudo docker run -p 8080:8080 jimbasilio/com.basilio.hiit
....loads of spring boot stuff printed to stdout to let you know what's going on

Now, point your browser to http://localhost:8080 you’ll see the hiit app (in all its skeleton glory) show up. Also, notice the console out messages being emitted from the docker container that’s being executed.

I can also run another container on port 8081 and it will happily startup

[jim@galago~/projects/HIIT (master)]$ sudo docker run -p 8081:8080 jimbasilio/com.basilio.hiit

Now point your browser to http://localhost:8081, you’ll see console message from hits to that port. The cool thing is the Spring Boot application has no idea it’s serving on port 8081, because it’s really bound to the docker container’s port 8080. At this point I could go more advanced and put a load balancer in front of both port 8080 and 8081 and optimally flood my CPUs (although realistically on 1 machine java will already do this quite happily by threaded connections through Tomcat).

Bottom Line

Docker is something that takes some getting used to. Thinking about the final Docker image as an ‘executable’ AND also an immutable (and comprised of) series of inner containers with each building on the previous immutable image helps things (at least it will help things once they start to click).

Being able to spin-up your ‘exe’ wherever you are (think dumb cloud box), not having to worry about what the host system has installed, and the very low overhead that containers have gives you one more tool in the toolbox to manage your application.

More examples of Docker usage are a maven docker image so you don’t have to worry about your CI builds (i.e. Jenkins) having maven installed. You can simply  have Jenkins start the maven docker container, share a volume with your sourcecode, compile/run tests, then the stdout is checked for success.

Docker is an endless thought experiment which really opens a lot of doors for creative (and reproducible) solutions.

Good luck and ENJOY!

Add better git support to your bash shell

Add this to your ~/.bash_rc

if [ -f /usr/lib/git-core/git-sh-prompt ]
then
  source /usr/lib/git-core/git-sh-prompt
  export PS1='[\u@\h\w$(__git_ps1 " (%s)")]\$ '
fi

Then watch your shell go from this

[jim@galago~/projects/HIIT]$

to this

[jim@galago~/projects/HIIT (add-docker)]$

Notice the branch name (add-docker) in the prompt?

You’ll also have command completion for git commands (i.e. git a<tab><tab> will show)

[jim@galago~/projects/HIIT (add-docker)]$ git a
add        am         annotate   apply      archive

And you’ll have command completion for the branches et al (i.e. git checkout <tab><tab> will show)

 

[jim@galago~/projects/HIIT (add-docker)]$ git checkout 
add-docker          HEAD                ORIG_HEAD           origin/HEAD         reactify 
FETCH_HEAD          master              origin/add-docker   origin/master

Enjoy!

Back to the future – Dell XPS 9350 (4.4-rc7 kernel)

My previous post on this topic talked about a mechanism for installing a custom 4.3 kernel that has the broadcom wireless drivers built in. I found a cleaner way to run a 4.4rc7 kernel from ubuntu that supports wifi, has no audio sizzle/static, and seems to run everything wonderfully.

It’s as simple as the following steps (as detailed on this blog)

cd /tmp
wget kernel.ubuntu.com/~kernel-ppa/mainline/v4.4-rc7-wily/linux-headers-4.4.0-040400rc7_4.4.0-040400rc7.201512272230_all.deb kernel.ubuntu.com/~kernel-ppa/mainline/v4.4-rc7-wily/linux-headers-4.4.0-040400rc7-generic_4.4.0-040400rc7.201512272230_amd64.deb kernel.ubuntu.com/~kernel-ppa/mainline/v4.4-rc7-wily/linux-image-4.4.0-040400rc7-generic_4.4.0-040400rc7.201512272230_amd64.deb
sudo dpkg -i linux-headers-4.4*.deb linux-image-4.4*.deb

Once you are done the above, reboot and select the 4.4 kernel (it may go to this by default). For me, everything “just worked”.

Also, whatever you do, don’t forget to install libinput’s X touchpad driver – it’s superior to the synaptic driver in every way.

Can’t wait until an official release from Dell and/or ubuntu 16.04 – until this I’m happy as a clam on this laptop. It’s a dream form factor, battery life, and power combination (assuming you aren’t intending on running games).

Back to the future – Dell XPS 9350 (4.3 kernel – old)

The Present

So my first post on this blog was about the Dell XPS 9333 compared to the System76 Galago UltraPro – I bought the System76 and don’t regret it at all. It’s a beast. The GPU is VERY strong (not as good as a discrete GPU but much better than the normal laptop level embedded GPU), the CPU is a MONSTER quad-core beast. The downside is battery life – it stinks. 3 hrs max .. if you are working it hard much less.

The Future

So with Dell’s new XPS 13 Skylake 9350 AND with a $100 rebate from MS I had to buy-in again. It’s just too nice of a footprint/screen/battery life to pass up. I love my Galago, but I love battery life when I don’t need the horsepower.

The Problem

Only problem is I didn’t want to run windows on it. MS was kind enough to give me $100 discount through a Christmas 2015 promotion, but I’m a linux guy and windows just isn’t as good for me. Problem is Dell’s Sputnik program doesn’t have everything worked out yet since Skylake is still fairly new and the drivers are only now in the 4.4 kernels which, as of this writing, are still in release candidate phase.

But never fear, here’s what I did to get it running!
NOTE: You’ll need a machine that DOES have internet access to do the below steps to copy the file to a thumb drive or other medium to transfer

  1. Put Ubuntu 15.10 on a thumb drive (get it here)
  2. Follow these steps on this wiki to download a custom 4.3 kernel
      1. If you don’t want to go to that link, download the custom 4.3 kernel by clicking this
      2. Go to terminal and change to directory you downloaded the file
      3. Enter the following
    tar jxf xps13_9350_kernel.tar.bz2
    sudo chown root:root brcmfmac4350-pcie.bin BCM-0a5c-6412.hcd
    sudo mv -t /lib/firmware/brcm/ BCM-0a5c-6412.hcd brcmfmac4350-pcie.bin
    sudo dpkg -i linux-headers-4.3.0-wifitest-custom_4.3.0-wifitest-custom-10.00.Custom_amd64.deb linux-image-4.3.0-wifitest-custom_4.3.0-wifitest-custom-10.00.Custom_amd64.deb
    
  3. Reboot and enjoy (NOTE: there is an issue with this 4.3 kernel where there is some static that comes from the speaker, this is more noticeable with headphones plugged in.)

I have had great luck with the above. I’m quite positive that I’ll have better luck with an official kernel and especially 4.4, but until then I’m not taking any kernel updates but do take all the other updates that ubuntu pushes.

Alternative

An alternative is to just buy an intel wifi device (http://www.amazon.com/gp/product/B00GUNZUG0) and be done with it. 🙂

Also…

No matter what you do above (custom kernel or new wifi device) make sure you update from the X synaptic driver to the libinput X driver – it’s MUCH better.

Use these steps on a previous post.

libinput and ubuntu 15.10 + 16.04

Why is there an issue?

One area that X has really fallen down on is the driver for the touchpad. It’s passable if you tweak it .. but why settle for passable? Shouldn’t the open source world have a KILLER touchpad implementation ala OSX?

For a very brief time I owned a Macbook Air and that’s the single biggest thing I miss about that hardware – Apple completely NAILED their touchpad feel. It feels natural and like an extension of your hand/fingers. You NEVER are frustrated with it.

…in steps libinput

You can read about libinput gory details on the projects wiki page. The long and short of it is that with wayland maturing and with the touchpad driver tightly coupled with xorg (and not very good or modern) there was a need for a better designed driver. Peter Hutterer (who-t) and some others have spearheaded this effort and have something quite polished and ready to show for it. And the best thing is you can run it as the driver within xorg!!!! This means you don’t have to run wayland OR Mir to enjoy your cake NOW!!! CAKE!!!

How do I run it!?

If you are running ubuntu 15.10 or 16.04, I answered the question on askubuntu. I’m not sure the steps on other distributions …

I also imagine this won’t be fully integrated into Ubuntu system configurations until Mir is integrated (i.e. natural scrolling checkbox, increase/decrease double click time/other tweaks via the Control Panel). Canonical has announced that they intend on utilizing libinput, I hope this is still true – it would be lovely if this integrated into the Control Panel in 15.10 if you install libinput – for now follow my directions on askubuntu (link above) and adjust the text file to add PalmDetection and Tapping.

Enjoy!!

Spring Async is so easy! (once you know the tricks…)

All source code under my github account.

Summary

Spring Async is designed to make threads easy to implement. It was introduced in Spring 3.0 intending to make Future easier to use as an annotation on Components (since then, CompletableFuture<T> has been introduced in Java8 and adds a ‘promise’-like framework, a topic for another blog). The key to using it correctly is realizing you MUST create your @Async annotated classes in another (Spring component) class so Spring can proxy it. More info below…

Background

A little background (with as much depth as I can provide without hopefully going beyond what I know as truth). At its core Spring is a Dependency Injection (DI) container. You may know this already, I did too and still fell into this @Async trap. In addition to a DI container, Spring also has lots of magic with instrumentation, AKA Aspects. When you annotate something in Spring (ex. @Async) what you are actually doing is telling Spring “when you load this class, you should apply AOP as methods are invoked” (i.e. points that Spring will invoke prior/after to invoking the function itself).

If you look at the spring example for @Async you’ll see that it requires you to put your @Async methods in a new spring bean, you CANNOT annotate local functions and invoke them and see any new threads created.

Creating a local instance of the FacebookLookupService class does NOT allow the findPage method to run asynchronously. It must be created inside a @Configuration class or picked up by @ComponentScan.

Back to the point

So given the above, it becomes more obvious (hopefully) why the @Async annotation needs to be present, because if it’s not Spring can’t wrap the calls prior/after to the function in order to create all the wrappers necessary to run your code through the boilerplate code in spring.

The hard way

(coming)

The easy way

First we need to turn on our @Async notations.

  1. @SpringBootApplication
  2. @EnableAsync
  3. public class SpringAsyncApplication {
  4.  
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SpringAsyncApplication.class, args);
  7.     }
  8.  
  9. }

Then we need to create a new spring component (in this case an @Service) so that spring can wrap things correctly:

  1. @Service
  2. public class AsyncService {
  3.  
  4.     @Async
  5.     public Future doFoo(String someArgument)
  6.             throws InterruptedException {
  7.         System.out.println("about to start Foo service (good async)");
  8.         Thread.sleep(3000);
  9.         System.out.println("finishing Foo service (good async)");
  10.  
  11.         return new AsyncResult(
  12.                 "Congrats. You finished a real thread from Foo Service (good async)");
  13.     }
  14.  
  15.     @Async
  16.     public Future doBar(String someArgument)
  17.             throws InterruptedException {
  18.         System.out.println("about to start Bar service (good async)");
  19.         Thread.sleep(3000);
  20.         System.out.println("finishing Bar service (good async)");
  21.  
  22.         return new AsyncResult(
  23.                 "Congrats. You finished a real thread from Bar Service (good async)");
  24.     }
  25. }

The output of our application shows things executing in parallel

[jim@galago~/projects/SpringAsync (master)]$ mvn clean package
...
[jim@galago~/projects/SpringAsync (master)]$ java -Dspring.profiles.active=goodasync -jar target/async-0.0.1-SNAPSHOT.jar
...
Starting up REAL async services.
Took 3 ms to start threads.
about to start Foo service (good async)
about to start Bar service (good async)
finishing Foo service (good async)
finishing Bar service (good async)
Foo done in 3018 ms.
Bar done in 3018 ms.
Total time ellapsed 3018 ms.

It took approximately 3s to execute both threads in parallel. If this were serially executed we would have seen things finish in over 6s (see ‘the wrong way’)

The wrong way

In this example we annotated local functions with @Async …. and things execute serially:

  1. @Component
  2. public class MyRunner implements CommandLineRunner {
  3.     @Autowired
  4.     private AsyncService realAsyncService;
  5.  
  6.     @Value("${app.goodasync:false}")
  7.     private boolean isGoodAsync;
  8.  
  9.     @Override
  10.     public void run(String... args) throws Exception {
  11.         Future fooService;
  12.         Future barService;
  13.  
  14.         StopWatch swOverall = new StopWatch();
  15.         swOverall.start("overall");
  16.  
  17.         StopWatch sw = new StopWatch();
  18.         sw.start();
  19.  
  20.         if (isGoodAsync) {
  21.             // call async methods through service call
  22.             System.out.println("Starting up REAL async services.");
  23.             fooService = this.realAsyncService.doFoo("an argument");
  24.             barService = this.realAsyncService.doBar("another argument");
  25.         } else {
  26.             System.out.println("Starting up BROKEN async services.");
  27.             fooService = this.doFoo("an argument");
  28.             barService = this.doBar("another argument");
  29.         }
  30.  
  31.         sw.stop();
  32.         System.out.println(
  33.                 "Took " + sw.getTotalTimeMillis() + " ms to start threads.");
  34.  
  35.         sw.start();
  36.         fooService.get();
  37.         sw.stop();
  38.         System.out.println("Foo done in " + sw.getTotalTimeMillis() + " ms.");
  39.  
  40.         sw.start();
  41.         barService.get();
  42.         sw.stop();
  43.         System.out.println("Bar done in " + sw.getTotalTimeMillis() + " ms.");
  44.  
  45.         swOverall.stop();
  46.         System.out.println("Total time ellapsed "
  47.                 + swOverall.getTotalTimeMillis() + " ms.");
  48.     }
  49.  
  50.     @Async
  51.     public Future doFoo(String someArgument)
  52.             throws InterruptedException {
  53.         System.out.println("about to start Foo service (broken async)");
  54.         Thread.sleep(3000);
  55.         System.out.println("finishing Foo service (broken async)");
  56.  
  57.         return new AsyncResult(
  58.                 "You finished a broken thread from Foo Service (broken async)");
  59.     }
  60.  
  61.     @Async
  62.     public Future doBar(String someArgument)
  63.             throws InterruptedException {
  64.         System.out.println("about to start Bar service (broken async)");
  65.         Thread.sleep(3000);
  66.         System.out.println("finishing Bar service (broken async)");
  67.  
  68.         return new AsyncResult(
  69.                 "You finished a broken thread from Bar Service (broken async)");
  70.     }
  71.  
  72. }

We expect that we will see execution time serially occurring, meaning in 6s

[jim@galago~/projects/SpringAsync (master)]$ mvn clean package
...
[jim@galago~/projects/SpringAsync (master)]$ java -Dspring.profiles.active=badasync -jar target/async-0.0.1-SNAPSHOT.jar 
...
Starting up BROKEN async services.
about to start Foo service (broken async)
finishing Foo service (broken async)
about to start Bar service (broken async)
finishing Bar service (broken async)
Took 6002 ms to start threads.
Foo done in 6002 ms.
Bar done in 6002 ms.
Total time ellapsed 6004 ms.

And this is exactly what we see…

Bottom Line

Spring is such a useful framework because it captures boilerplate code in a useful manner to save you time developing AND to save you bugs in what is normally foundational code. You shouldn’t feel you MUST use Spring for everything, but if it solves your problem it will likely save you bugs you may have written. Threaded code is ESPECIALLY nasty when you miss something.

For me, once I realized my @Async code needed to be in a separate @Bean/@Service/etc I was able to benefit from Spring’s logic.

Thanks for reading!

Spring boot (profiles)

Background

I’m pretty new to the spring ‘scene’.  I did Java work out of college for quite awhile, even working on J++ (anyone remember that?) for a few years until moving companies and transitioning to C#/.net for a full 10 years.  I’ve always been interested and motivated by the open source community and the work that goes into these projects, but .net hasn’t historically lent itself to this community (I do have to say, MS does seem to be changing things a little bit here recently).

However, this all changed at the end of 2013.  I was (luckily) involved in a project at work that utilized Spring to reboot our group to have more java in the mix.  Alongside java was linux as the development environment.

The Experience

Just like with any new technology stack, spring felt fairly overwhelming.  The java world had matured a LOT since I was last involved with it – spring was very deep and pretty confusing, but I could see that the spring team was solving very common enterprise problems with very strong design patterns.  I WANTED to learn more about spring, I WANTED to learn more about Java and the current state of the language.

What followed was a few months of picking up lots of things to get current on the language, Maven, and Spring itself.  I realized that it was VERY difficult to even START a spring application and there was lots of confusing documentation out there that used both XML and Java Configurations and it was hard to find the right information at the right time.

That’s where Spring Boot stepped in.

Spring Boot

Spring Boot has felt like a breathe of fresh air to me.  It’s focused Spring itself on an ‘opinionated’ stack (i.e. choices made for you for common scenarios) while still allowing overrides for those opinions in order to solve specific issues or decisions you have made or just plain prefer (i.e. want to use log4j instead of logback?  no problem, just add it to your classpath.  want to use Eclipse Link instead of Hibernate?  spring boot has you covered).

My first test of spring boot was to try to to write a simple application that used multiple databases.  The scenario was multiple Profiles, minimally 1 for dev and 1 for production.  I wanted to see how Spring Boot would allow me to seamlessly switch between profiles and how quick and effortlessly (or not) this would be, so I created a simple application at https://github.com/jimbasilio/SpringBoot-profiles.

While profiles may not be the sexiest topic, it’s one that is pretty important when developing an application in order to be able to quickly transition from your dev environment to your production environment (with ideally a test environment to boot). In the spring docs it has a section devoted to profiles.

The Spring Boot Documents (1.1.0) are a GREAT source of information and pointers to example projects from the Spring team itself, but sometimes they don’t go deep enough. For my test project I added both h2 and hsqldb to my classpath via my pom.xml file.

hsqldb and h2

This pulls both databases in for access via spring, which you can then specify settings in your application*.properties files to decide what you want to use, and more importantly when. In order to specify the ‘when’ for using different databases you simply need to pass an argument to spring boot via the JVM parameters:

After some experience at work, I realized that choosing profile definitions based on environment (i.e. dev or prod) is not a good idea. It’s too inflexible. Instead, creating profiles for each segment of your app that you want to pull in is preferred.

For example, if you have multiple databases to support, define a profile for each (application-hsql.profile, application-h2.profile). This way you are able to shuffle in different features to test without having to dictate what a ‘production’ environment is. Instead, define your production environment based on the profiles you need to use and put these on the commandline that you will run in production.

Another example is if you want an awesome feature on at TIMES, but by default this feature can be off. When you include the properties definition you can default it to false:

awesome feature disabled

But when you are ready to turn this feature on you can simply put it on your commandline and it’ll pull in the properties file and turn it on:

with awesome feature

When you add the ‘awesomefeature’ to the commandline and visit the controller you’ll see the proper text indicating the feature is active.

awesome feature browser

Summary

So in summary, spring boot is great for getting off the ground QUICKLY with all the goodness that spring provides. It allows you to hook in and dictate the behavior you want (not discussed in this blog) and also has the ability to select ‘profiles’ that can be used for all sorts of useful combinations of features when testing and building to production.

Hope you enjoyed reading!

Dell XPS 13 – Developer Edition vs System76 Galago UltraPro

Summary

I had been using an Asus Timeline M5 for a couple years but the laptop’s resolution (1366×768) and smallish battery life (~3hrs) was something I was not happy with anymore.  I wanted a laptop that ran linux ‘out of the box’ (if at all possible) since I didn’t want to muck with installation and making everything work 100% (i.e. media keys, sleep/resume, etc).  My requirements were solid battery life (ideally > 4hrs), good resolution (ideally 1080p), and linux support with minimal (aka zero) fuss.

(Update 12/2014 – This post is sort of confusing because of how the timeline went down. The short story is I returned the XPS 13 because of the coil whine and Dell has a serious problem on their hands with how they’ve handled this. I bought the Galago UltraPro and I’m as happy as I could possibly be, it’s an amazing machine in all aspects. Please keep reading for the timeline of events and sorry for the confusion, it was a very confusing time for me too :).

My Background

To give some background on me and my computing/hardware history, I’ve been running Linux since my college days around ’95. There was a brief time when I didn’t have linux on SOMETHING, but it’s been my daily driver for a LONG time. I used to be a pretty hard core KDE person, went onto Ubuntu/Unity for quite a few years, then recently I tried Gnome 3.x and LOVED it.   I went back to Ubuntu/Unity when I got the dell XPS 13 [*spoiler*! :)].

The Requirements

I wanted a laptop for hacking around for programming, general web browsing, and I MAY play a game or two on it in Steam but I have a Windows Steam machine for that with a beefy GPU so this was not a deciding factor really.  I wanted a nice footprint (ultrabook-like) and I really wanted long battery life, I was sick of the 3hrs (at best) that I would get with my Acer.

The Contenders

The list of laptops that run linux, have good battery life, have good screen sizes, and have a nice footprint is pretty …. thin (to say the least).  LUCKILY the list has 2 REALLY nice laptops on the list.

It came down to the Dell XPS13 and System76’s Galago UltraPro.

System76

I had been following System76 for quite some time and really love their company involvement.  They have a good social media presence, they support their products very well, and they are an up and comer.  Their Galago UltraPro is a POWER machine.  It’s got a SUPER CPU/GPU in it, but it comes at the cost of battery life.  The screen is a matte screen which appealed to me a lot, I really didn’t need the screen to be a touch screen and didn’t want to pay for this feature since I’d rarely (if ever) use it.  My wife has a Yoga2 with a touchscreen and she NEVER uses the touchscreen (she loves that laptop BTW, hates win8).

Dell

Dell has also committed lots of resources to drivers and making sure linux ‘just works’ on their XPS 13 as well.  They have stuck with their Sputnik program for years, which is tasked to fully support a developer edition of the XPS 13.

The Decision

Price wasn’t cheap for either laptop, they were both pretty similar once you configured the options.  The dell couldn’t go higher than 8GB ram, but with an SSD swap partition, things aren’t too terrible there.  The CPU on the dell isn’t as powerful (I got the i5), but I’m not compiling millions of lines of code , mostly just hacking around.  So the deciding factors  came down to the footprint of the laptop and the battery life.  The XPS13 is a true ultrabook and the battery life is OUTSTANDING. The Galago UltraPro runs at less than half the battery life of the XPS and the XPS form factor is absolutely outstanding – it’s a PREMIUM feeling machine through and through.

I decided on the XPS13 because of the footprint and the battery life.  I didn’t need the extra horsepower the System76 machine provided and I DID want the extra battery life.  The footprint was an added bonus (a really nice looking bonus).

THE FLAW

I was REALLY excited to get the laptop, it took a few weeks from when I ordered it to arrive.  I unpacked it and turned it on and there’s an AWESOME boot animation they’ve done .. really nice opening presentation.  I connected to my wifi and things were a little less awesome, I was getting connection disconnects.  I also noticed a high pitched electrical sound coming from the laptop, seemingly from just under the usb port on the top right of the keyboard.  If I played with the backlit keyboard settings I could get it to go away. I also found that if I plugged in a USB stick on that port it would quiet down.  But depending on system load, what the fan was doing, maybe the chance of rain that day, the ‘coil whine’ would start up again.  I have ALWAYS been able to silence it 100% by toggling the backlit keyboard to 1 of the 3 settings (it’s always a different one that silences it depending on the other factors going on with the power draw at the time).

I contacted dell support the next day and had a VERY positive experience.  They were on the problem right away and within literally 5 minutes I had an appointment with a tech specialist to come to my house in the next 2 days to swap the motherboard to try to fix the coil whine and the wifi dropouts.  I was really impressed.

Before the technician arrived I decided to try 14.04LTS on it (it came with 12.04LTS) to see if that helped the WiFi, it had a drastic effect and after the upgrade I had no WiFi issues at all.  I also upgraded my router at home (a week or so later) to an Asus RT-AC66U, the XPS connected flawlessly to this and now has amazing throughput and signal coverage (btw: can’t say enough positive things about this router.  the signal coverage is amazing [way better than my juiced dd-wrt buffalo router before it] and the features are the best I’ve ever seen).

I started doing some more research into the coil whine and came across this thread on the dell support site.  After reading through the forum, the coil whine appears to me to be a design defect.  If you read through the thread, you’ll find tech support seemingly admitting to the defect and most recently stating the motherboard is being redesigned to eliminate the noise (as of end of May 2014). I’m hoping that means they’ll send out free replacements to their current customers – honestly if they fixed this problem this is about the perfect machine for me.

UPDATE 12/2014 – Dell has an updated motherboard with the same problem. They are not going to fix this anymore and have stated this. The thread I linked above has massive amounts of complaints and I would STRONGLY advise against buying the XPS. Dell has just lost all credibility on this laptop and strung people along with the promise of a fix for too long.

The EXPERIENCE

So with that out of the way, my feelings on the product are that it’s OUTSTANDING.  I’ve had it now for a little over a month and I love it. The drivers dell worked on for 12.04LTS have been pushed upstream and the upgrade to 14.04LTS went without a hitch. Every aspect of the machine ‘just works’ (except the coil whine obviously).  Ubuntu looks GORGEOUS on it.  Unity absolutely SHINES.  I also have a Dell UltraSharp U2711 27″ monitor (resolution 2560 x 1440, omg i love this monitor) which can only be driven PROPERLY by a Display Port connector and it connected flawlessly (you can use HDMI but it’s a rotten experience, I went through it with my Acer). The multi-monitor support in Ubuntu’s Unity is bar-none the best I have experienced.  At work I use a windows 7 machine in a docking station and every now and again it’ll go wonky or windows will go off screen, not often but it happens, but Unity has been flawless.

The speed of the laptop is pretty much instantaneous.  I don’t wait for anything, everything ‘just works’, I was able to set the function keys to be ‘media’ keys in the BIOS (i.e. hit the Fn button to use them as function keys) which is how I prefer to have it .. the ONLY thing I needed to do (again, in the BIOS) was disable Intel’s “Smart Connect” so the laptop STAYED asleep when I shut the lid, otherwise it would wakeup sometimes even with the lid shut. This behavior happens to me on my Windows Steam machine too, so I blame the stupid Intel SmartConnect feature and not the laptop. Shutting this off in the BIOS prevented the laptop from accidental wakeups 100% of the time.

The Bottom Line

So after all of the above I have to say I’m tickled beyond belief with this laptop.  Ubuntu/Unity has been a wonderful experience, Unity is such a mature environment and it does what I need it to do and gets out of my way.  The workflow is outstanding.  The laptop hardware OOZES premium feel, the touchpad behavior is the best I’ve ever felt on linux (far beyond windows, not quite up the the level of mac but close enough and still an excellent experience).  The battery life is also outstanding at 7-8hrs. I also REALLY appreciate that the bottom of the laptop is carbon fiber instead of metal.  Metal under a laptop gets either hot OR VERY COLD, I am not a fan of metal laptops UNDERNEATH (on top I think it looks sharp).

Dell has designed damn near a perfect laptop here for Linux users/developers.  They have GOT to solve the coil whine though.  It’s damaging to their reputation, it’s frustrating on such a premium product, and it’s just something they need to get beyond.  They should look to how System76 handled their keyboard debacle, and to be fair to Dell it took System76 quite some time to ‘admit’ to this issue but at this point they’ve taken the high road and are much better off for it due to customer loyalty and satisfaction.

Checklist of things to do

In summary the things to do with this laptop if you do get one:

  1. Update to 14.04 LTS.  It’s painless and a much better experience.
  2. Disable Intel SmartConnect in the BIOS.  It’s dumb and it wakes the laptop up when it’s sleeping.
  3. Realize the laptop WILL make the coil whine sound, it’s not terribly loud but you can hear it in a silent room.  Also realize you can make it stop by flipping through your 3 settings on the keyboard backlight, 1 of the settings will make it stop.
  4. Adjust the ‘media keys’ or ‘function keys’ behavior in the BIOS as well.  I love media keys personally since I use them MUCH more than Fn keys and Fn keys aren’t hard to use with the Fn button.
  5. ENJOY IT!!  It’s such a nice machine and Unity is such a nice desktop environment.  I’m so happy to be able to buy linux on premium hardware and not have to fiddle with it – hopefully there’s more of this to come. 🙂

If you are in the market for a laptop with great battery life, great form factor, and premium feel – consider the xps 13.  I’m glad I did. (UPDATE: As stated above, I returned the XPS 13 – just to be clear)

For my next post I’m going to focus on Spring Boot and their profile support.  I’d like to start a series on Spring Boot based on lessons I’ve learned for little things that highlight sections of their documentation.

Thanks for reading!

Jim

(UPDATE: I had to disable the tap click for the touchpad.  Somewhere around mid-May I started getting clicks on the touchpad when I lifted up my finger on the touchpad.  I don’t know why, and I fiddled with xinput and synaptic settings and couldn’t get it to go away.  As of right now I have to physically ‘click’ the touchpad … it’s not terrible but it’s not what I wanted).

(UPDATE TO THE UPDATE: I finally bit the bullet and returned the XPS 13.  It took hours on the phone with Dell and quite a few support people but Dell was a good enough company to finally take the return for their flaw in the laptop.  I ordered a Galago UltraPro and I’m very happy.  The battery life is around 4 hrs or so, but the Iris Pro is REALLY killing it.  I bought with a HDD to save a couple bucks and while bootup is certainly slower, once it’s running the i7 really shows its power.  I’m happy to have the ability to play Steam games and the laptop itself is quiet, NO pop on the headphones, very very solid).

12/2014 update – I’m still in love with the system76 laptop. It’s a beast in CPU/GPU and with the SSD I feel like this laptop is capable of anything I could reasonably want to do with it. I couldn’t be happier. Maybe I’ll make a dedicated blog post to just the system76 since this blog post evolved so much with my experience on the Dell and may be confusing.