I’m joining Domo!

Who’s Domo you ask? They’re a rising technology company located (right here) on the Silicon Slopes. They’re a cloud-based executive management platform that gives vision to visionaries.

Marketing speak aside, they’re making the term “business intelligence” not such an oxymoron.

It’s run by the amazing Josh James and has some high-profile backers.

Domo is still in stealth mode, but after siging an NDA and seeing the product, I’m sold.

They’re solving some hard problems that nobody else has been able to. In fact, I don’t think it’s hyperbole to say this business intelligence company is going to change the world.

I’ve seen an interesting search keyword on my Google Analytics recently. It’s fairly impressive and given me some newfound respect for recruiters.

(intitle:resume | inurl:resume) “ios” “ut” -~job -~jobs

Here’s the breakdown of what it does:

(intitle:resume | inurl:resume)

Uses the or operator with the web serach operator (intitle and inurl) to show results with the word “resume” in the title or the url.

“ios” “ut”

The page forces Google to return pages that have both the terms “ios” and “ut”.

-~job -~jobs

The minus character tells Google to omit pages that have a particular word in them. The tilde is the synonym operator and is used to find (or in this case exclude) synonyms of job and jobs.

I had a great time teaching an AngularJS workshop for the Utah GDG October meeting.

The sample application code (and presentation slides) is available on Github.

I wanted an easy way to periodically backup my code on Bitbucket and Github. Here’s my first attempt at backing up my repositories.

Written in Ruby, the Bitbucket repository backup script uses the Oauth API to get to my private repositories. With Github, I only have public repositories, so the Github repository backup script uses their standard API.

I had a great time learning, diving into, and presenting with Miles Pomeroy and Jonathan Geddes on our polyglot topics.

We did two presentations: 9 Languages in 45 Minutes and 9 Databases in 45 Minutes.

It was an experiment on a technical presentation format where we essentially did nine 5 minute lightning talks on different languages and databases (complete with air horns to let us know when to switch).

Languages we covered:

• Erlang
• Go
• Haskell
• Io
• Lisp
• Prolog
• R
• Ruby
• Scala

Databases we covered:

• CouchDB
• HBase
• Marklogic
• MongoDB
• Neo4j
• Postgres
• Redis
• Riak
• VoltDB

So what am I most excited about and will keep playing with? That would be Go (so awesome - it’s like the best of all languages rolled into one), R (say goodbye to spreadsheets forever), and VoltDB (newSQL awesomeness).

UPDATE (2012-10-14): Added link to Miles’ recording of the presentation on Youtube.

I got in on an early developer release of a few Electric Imp boards. I first saw them at the Maker Faire and was blown away. I have to say they are amazing! The “internet of things” is for real, and these guys are leading the charge. Here’s what I did with mine.

I have this theory that I can make my house more efficient by improving air circulation between the loft and the basement. I eventually plan on running two 4 inch ducts between the basement and the loft and having in-line duct fans push and pull air to help circulate it based on the variation of temperatures. This should take the load off the A/C unit and make the temperatures more consistent. But first, I need a baseline to see if my theory is correct.

That’s where my electric imp and the Hannah board comes in (and a helpful Raspberry Pi and Temper1 USB temperature sensor).

I’ve got the Hannah board in the loft with the imp sending the current temperature every 10 minutes to a Ruby application hosted on Heroku. I also have a Ruby client on the Raspberry Pi that is sending the basement temperature and another that gets the current outdoor temperature from the NWS (for correlation purposes). It’s pretty sweet.

What I love:

• Over-the-air updates are amazing. You save on the developer website and watch those LEDs on the Imp board show it’s updating. No serial cables or nuthin’. It’s really like magic.
• Setting up WiFi for the Imp is a snap with an Android (or iOS) device. No joking, the app flashes your phone’s screen to transmit WiFi configuration settings to the Imp so it can connect. It’s science fiction.
• I’m really digging Squirrel. It’s small, expressive, and much more fun than working with Arduinos. A great choice in programming languages.
• Sending the collected data from Hannah board to an external service is literally as easy as a few clicks and drags in the developer planner.

There is only one thing that could be improved (and from their forums it looks like it is in the works). That would be more control over external HTTP services. Currently, a JSON HTTP POST structure can’t be modified. It works for my purpose, but I would love the ability to change the JSON structure and have full control of the HTTP request.

My (poorly documented and quickly cobbled) code for the project is on Github.

Oh, and they’ve also just become widely available through Sparkfun. Go get some now (yah, it’s worth buying them now rather than waiting and chancing it on the next free day).

These guys are definitely a startup to watch.

In case you hadn’t noticed, we live in a polyglot world. As a developer (in my mind anyway), you have two options.

1. You can sit back and double-down on your primary language (probably Java) and force it to work for everything (regardless of whether it should or not).
2. Or, you can embrace change, new development paradigms and languages so that you’re capable of always developing closest to the platform you’re delivering on.

Matt Might said it best:

One should always choose the programming language that reduces the impedance mismatch between a problem and its solution.

Or, in other words, don’t use Java in the browser for rich web applications and don’t use web technologies for native mobile apps. On an editorial note and IMNSHO, every developer should be JavaScript proficient. It’s not the assembly of the web (I’ve never seen any assembly that is powerful, expressive, and a multi-paradigm advocate, have you?). It’s not bad (or more bad than other languages) and it has a lot more good parts than people give it credit for. On top of that, it’s ubiquitous.

I’m not saying there’s something wrong with Java. It’ll be around for a long time (forever maybe). It just may not be the best solution for all your problems. I also think that “Java as a platform” (i.e., the virtual machine) has a big future (think Scala, Jython, Clojure, etc).

Enough editorializing, option two above is the best. Embrace change. Be uncomfortable. That’s how you know you’re learning.

Here’s how you can grok new languages and get up to speed quickly. Keep in mind that the only way to achieve true mastery of a language is to put in the keyboard time. This just helps you ramp up quickly.

1. Get some context (ignore the pundits and the stereotypical developer hubris - at least at first)
   • Why was the language created?
     • For example, Lua was created in Brazil due to trade barriers that caused it to be built domestically from scratch.
   • What “itch” did it “scratch”?
     • Io was built out of desire to get to know how languages worked.
   • When was it created? What was going on in the industry during that time?
   • What languages inspired it?
     • Squirrel (used by Electric Imp - they’re awesome, BTW!) was influenced by JavaScript and Lua.
2. What programming paradigm does it advocate?
   • Single paradigm or multiple paradigms?
     • If you are unaware, there are four main paradigms: object-oriented, imperative, functional, and logic programming.
3. Dive into the language
   • I like to setup a Github repository (or Bitbucket if you need to keep it private) when I dive into a language. For example, with R (that I’m still groking), I created a repository called ’learn-r’.
   • Create small examples and comment your code furiously. It may make sense now what you’re doing but when you come back, it won’t.
     • Name the file so it’s easy to see what it contains.
       • For a Go example, I created a file called ex3-variables.go for exploring the basic types.
     • Also, comment the top of each small code example with the purpose so it can be easily grep-ed when you’re looking for a reference.
   • This varies a bit with each language, but you’ll probably want to follow something close to this:
     • Setup - do you need to install an interpreter, a compiler, dependencies?
       • Try and avoid an IDE initially. They help, but sometimes they abstract your setup too much.
     • “Hello World”
       • This checks to make sure you have your environment all setup.
     • Comments
       • An important part of coding
     • Variables
     • Decisions & Conditional statements
       • while, if, switch, etc
     • Functions
     • Imports
     • Data structures
     • Project structuring
       • Any expected format? Packages?
4. See what the pundits are saying (try to find intelligent conversations, not 0).
   • Do a Google search on Hacker News.
     • For example, lots of good stuff is being said about Go recently.
   • Check out some of the popular questions on stackoverflow. Why were they asked, why are they popular?
   • There are some great books out there as well.
     • Seven Languages in Seven Weeks from the Pragmatic Bookshelf is great.
     • The Learn Code the Hard Way site has a handful of free books on Ruby, Python, C, etc.
   • Look at (sometimes seemingly random) rankings. tiobe.com or the recent RedMonk rankings.
   • Use Google Trends, see geographic areas searching for the technology (yah, Utah’s legit).

Most importantly, be intellectually curious. Go tangential. The most important thing is to ask why, and then try to answer that question.

I decided to put my recently acquired LaTeX skills to use and update my resume. It’s an amalgam of a number or resumes and ideas that I’ve admired recently. I wanted it to be concise (single page), well-designed, and light on fluff (no objective, etc.).

Here is the source and my finished resume.

I defended my thesis last week. It’s titled Test Case Generation Using Combinatorial Based Coverage For Rich Web Applications. In short, it’s an empirical study focusing on the challenges of applying combinatorial testing to client-side heavy, rich web apps.

I built a sample rich web application using Java, Spring, and Derby on the back-end and Backbone.js and jQuery Mobile on the client. It has a number of seeded JavaScript faults and it’s hosted on Heroku.

The full thesis is available here. I’ll update with code repository and LaTeX source after some cleanup.

Just finished a fantastic class on AspectJ at USU. Of great interest to me was the discussions and research papers we studied surrounding languages, design patterns, and the benefits and shortcomings of AspectJ.

We did a few skill building exercises. For my project I investigated the feasibility of integrating AspectJ with an Android application. After some setup, it worked!

My Android application used aspects for three cross-cutting concerns: logging, metrics, and persistence.