A Lightweight “CMS” Using Ruby and Google Drive

My current project includes a fairly large amount of static text written by our customer’s marketing team. The authors generally do not have the background to provide valid HTML or contribute changes directly to our codebase.

Since there is a large amount of this text and we anticipate frequent updates throughout the course of the project, we were looking for an automated process we could use to import this text, convert it to valid HTML, and create the appropriate templates in our project’s file hierarchy. While there are plenty of full-featured Content Management System (CMS) options out there, we wanted something very lightweight that could be easily integrated into our existing project and would be fairly painless for our customers to use.

We created a simplified “CMS” system with two steps:

1. Content authors enter text in a Google Drive spreadsheet we created. (Here’s an example.)
2. We use a Ruby script to grab the text from the spreadsheet and generate the appropriate templates in our application.

Read More »

I just finished a project that used a Kinect’s computer vision tools to gather information about people nearby, then communicate with other hardware to adjust the environment. (Vagueness due to NDA.) The Kinect’s SDK limited me to C#, C++, or Visual Basic, but the other device only had a USB HID interface (a generic human input device). Unfortunately, C# doesn’t have any native support for USB HIDs, and none of the several libraries I tried seemed ready for prime time. After digging deeper and deeper into their implementations and attempting to fix things, I decided to try another approach.

There wasn’t any reason my entire system had to be in C#, though. As long as the system agreed on a protocol, I could just use IPC (sockets) and build the controller side with whatever language had the right libraries. Python has a great Windows USB HID library, so I wrapped that in about a dozen lines of socket code, and it was good to go.

Later, the hardware vendor sent me a DLL that provided a higher-level C interface than raw byte buffers, so I replaced them with calls into the DLL. (Also from Python, via ctypes.) The C# code didn’t need to know or care about this, since its outgoing messages stayed the same. Breaking my system into small, autonomous components made me focus on what they needed to communicate to each other, and once that was established, I was free to change everything else.

Read More »

If your team is not focused on delivering intermediate project milestones, they are missing what’s really of value. It’s easy to miss the forest for the trees if you’re only focusing on task-level points estimates and velocity tracking.

I’ve become frustrated with how burn charts focus on showing progress through an entire backlog and don’t clearly show the importance of incrementally delivering chunks of value.

Burn Charts Are Not Enough

Atomic has been experimenting with several approaches to help us focus, report against, and manage scope against intermediate milestones.

Read More »

Sometimes it’s hard to just say what you mean.

When writing automated system and integration tests, I occasionally find it tricky to express the precise expected value of test output. For example, I expect the timestamp on a database record to be within a second or two of “now,” but I can’t predict the exact millisecond it will be created by the web server I’m posting to. And sometimes a floating point result is off by a millionth or trillionth, because the numeric representations used in my tests are not necessarily the binary equivalent of what the code under test is using.

In the cases where I know the differences are circumstantial (and irrelevant to my test), I find myself wanting to write…

assert_equal record.created_at, Time.now.ish
assert_equal bullet.velocity, 5.25.ish

…and have it “just work.” I know what I mean, and so (likely) will anyone reading the test after me.

Read More »

In my last post, I described how I was re-schooled in the basics of project management with the discovery of critical chain methods. We got amazing results by applying critical chain to our traditional software development projects:

• We challenged ourselves to find ways of delivering faster. This drove us to think backwards from the deliverable — what was really necessary, what could be worked concurrently, and what were the missing dependencies.
• We created work plans that minimized multi-tasking.
• We changed our work behavior to mimic a team relay race by:

• Starting work on a task only when it was truly ready (all dependencies were complete).
• Remaining heads down on a task until complete or blocked before picking up the next.
• Working each task to maintain quality and beat the schedule.
• Helping others when we had gaps between assigned tasks.

But how do these apply in projects using Agile’s Extreme Programming (XP)?    Read More »

The way that programmers and mathematicians work seems to be very different. Programming is about making computers do something, whereas math is about describing things. Programming involves state that changes over time, whereas math deals with Platonic theorems that are always true, even if not proven yet.

But, in fact, the Curry-Howard Isomorphism states that there is a very direct correspondence between basic logical concepts (namely, propositions) and basic programming concepts (namely, types). This correspondence has been known for a long time, but it is only recently that it has begun to creep into the actual practices of programmers and mathematicians alike.

Due to a recent advance in mathematics called Homotopy Type Theory, programming and math are about to be unified on a practical level in a way that will fortify their strengths and overcome some of their respective weaknesses.   Read More »

Every developer has their favorite tools and development environments. Sometimes it’s tough to get all the tools in place or the environment set up.

To aid in setup for your next project, try Homebrew. Like MacPorts, it aims to be the package manage Apple never included. But unlike MacPorts, Homebrew (Brew) is much easier to install, use, and contribute to. Brew is a great tool for Mac developers or all backgrounds.

Installing Brew is a breeze. Just copy one line from their website into Terminal, and it will run through a guided install:

ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)"

At the heart of Brew are git and ruby, so modification and updating are simple and can be reversed or committed to the project. Once all of the setup has occurred, you now have access to brew in the terminal. Brew keeps track of all the package versions via a git repository, so run brew up or brew update often. More commands can be found in the Homebrew Wiki or in the man pages of Brew.

Once Brew has been set up and updated, you can search for, install, and upgrade packages. Brew downloads the packages to its own directory and symlinks them into /usr/local. This allows you to update, install, and remove with ease – no worries about littering files all over.

If you need a specific older version of a package (like nodejs 4 and 6, since most nodejs hosts support one of these versions), there is a repository with some of them tracked. You can take a look at the tracked versions and the quick setup on Homebrew’s github page.
 

This is the snack counter in our office. It’s centrally located, which means the phrase “co-located, poly-skilled, self-managing teams of makers” is visible from pretty much anywhere in our office. I’ve written before about how our poly-skilled teams function. In that post, I touched on how our teams manage their own projects instead of reporting to a project manager. In this post, I want to talk a little more about this and to delve deeper into how self-managed teams are beneficial for makers, clients, and products alike.

Read More »

Recently, I was looking for an example of using the Nimbus library to help manage a UITableView and its respective cells. Their documentation covers a lot of the details, but I was having a difficult time seeing exactly how all the pieces of the puzzle fit together. I couldn’t find a good, simple example, so I made one. You can find it on github.

Nimbus provides some solid value dealing with displaying a list of models within a table view. It simplifies mapping your model classes to a specific UITableCellView subclass, managing cell reuse, and updating cell contents with values from a different object. Check out the example for more details.

Pull requests are welcome to improve or expand on the example.
 

We often hear that “design is an overloaded word.” This must be one of the biggest understatements of all time! Often when I’m communicating with others and the word design is dropped, we need to ask ourselves: are we talking about visual design? User experience? Markup? Tangible design? Tactical design? Strategic design? Or simply aesthetics?

Given all of the confusion, as I was skimming the Table of Contents of Bettina von Stamm’s Managing Innovation, Design, and Creativity, the appendix titled Categories of Design immediately jumped out to me. I thought, “ah, perhaps this will help build my understanding of the word design.”