This weekend I was invited by a few friends from the Ann Arbor PHP User Group to join them on Saturday night and figure out something to work on together.
TLDR: I need to do this more. It was immensely fun.
So it started off with a few ideas flying around on what to build, and then I’d mentioned that I have wanted to build an app for estimation poker since forever. Also — it seems I can be somewhat persuasive.
So the four of us sat down (Jonathan, Kelly, Jason and I) and we sorted out what our MVP (Minimum Viable Product to those of you who don’t live in startup land) was going to be. We settled on features and the basics of the protocol, and then had to pick technology. I’d seen that Ember.js seems particularly well built for building a multiple concurrent user system, so I suggested that, and I believe it was Jonathan who suggested Node.js for the back end, and of course — socket.io for communication. Jonathan and Jason would pair to build the back end, while Kelly and I would take the divide and conquer approach for the front end. With all of that decided, there was only one other choice to make…
Because it’s a fun name to say, that’s why.
So as of today, the minimum viable pieces are actually working. You can check out the github repository, or even see the live demo up on Heroku. I’m hoping we can maybe look at using it at work to help encourage participation during planning meetings perhaps, but even if that never comes to fruition, it has certainly been a fun project to work on, even just as far as it is now. It still has a lot of rough edges, but you can see it starting to come together.
So, I’m trying to make a point to have something posted every Monday — so for lack of better topic, my friends at work reminded me of a fun one: I used to smoke.
Normally, not a big deal, you quit, woohoo. But of course: I quit like a nerd.
Let’s not kid around: cigarettes are scary addictive. They controlled a lot of how I made my daily decisions on where to go and what to do. I suspect many smokers are like this, even if they’re not ready to admit it.
Want to go visit family? How long will you stay? Do you smoke around them? What about a movie? Is it too long? What about that restaurant? Oh, they don’t have a smoking section. Nevermind.
It was late 2009, April and I had just found out our first child was on their way to meet us, and so we needed to “become parents.” Yes, that sounds ridiculous even now, but it’s how it made sense in my head. It was time to start thinking longer term. One of those thoughts was:
I REALLY NEED TO QUIT SMOKING
So I started doing research, and I found out about electronic cigarettes. Then I did a lot more research.
Then I bought this:
And actually, what I bought was specifically (though an older packaging):
Titan 510 Starter Kit
Two batteries, two atomizers, mine actually came with a charging case for the batteries, which was quite helpful, as the batteries (at least then) didn’t seem to last particularly long (but then, my memory is also pretty fuzz at this point).
I got a “Tobacco” flavored “nic juice” (what they call the fluid that contains the nicotine, flavoring, and propylene glycol), liked it, and after a week of struggling, was happily 100% on e-cigarettes. Yes — I had withdrawal when switching entirely to e-cigarettes. Let’s be very clear here: nicotine is not the only thing in cigarettes that you are addicted to. If there was any question in your mind, let me make that clear. You will go through withdrawal switching to e-cigarettes from traditional cigarettes.
Once I had made the transition, a few weeks after that my body realized I was no longer “smoking” and … started, we will say, “removing” some of the “toxins”. Gross. Anyway, not long after, I had to start figuring out a long term plan to get off of nicotine completely. Now here came an issue: The nic juice I liked came in 24mg, 18mg, and 12mg “flavors” but that is as low as it went. They didn’t offer 8mg, 4mg, or 0mg versions, so I had to start trying to branch out my flavor choices into one that could support me stepping down to a 0mg nicotine fluid.
After many rounds, I was forced to give up on the pre-made option, as none of them either A) tasted good to me, or B) had 0 nicotine versions. So I did what any programmer does when nothing out their suits their needs: I rolled my own!
Let’s take a side-step and look at what nic juice is made of:
- Propylene Glycol
- Vegetable Glycerin
Now I’m not sure of the exact origin of the science of all of this, but it seems that they figured out they could extract nicotine from tobacco leaves with a Propylene Glycol based solution. I was able to find a business would send me a (relatively speaking) GIANT bottle of (I think) 36mg nicotine solution. Now this is not for the faint of heart. If I had spilled this solution on my hands, could have possibly died from nicotine poisoning. Kind of scary, but if you take appropriate precautions, it’s fine.
So I took this essentially flavorless nic juice, and had to cut it down. I didn’t need 36mg nic juice. But if I used 1 part nic juice and 2 parts propylene glycol (Remember to get USP grade, kids. It’s going in your body, it needs to be food-safe.), I would get a nice 12mg nic juice to start with. To that, I kid you not, you add candy flavoring. YES! CANDY FLAVORING! My flavor of choice, which tasted the best to me after all the ones I tried: grape.
That’s right, I smoked grape nic juice. And it was hilariously awesome when others caught a whiff of it, as it completely threw people off. Having full control of the nic juice let me slowly titrate myself down to 0mg, freeing myself from the horrors of smoking. Or so I thought.
2 weeks of vaping 0mg grape nic juice, and I started to feel a little silly. I needed to just stop, as there was now no gain from the action, aside from all the trouble associated with trying to create, maintain, and fill my own containers with candy flavored propylene glycol. It was a mess, it took quite a bit of time, I needed to be done.
So I quit.
Second reality check of the whole thing: even though the chemical addition was gone, my body rebelled against losing the habit of smoking. I had all of the classic nicotine withdrawal symptoms, with irritability being close to the top of them. It was a very tense week or two at my house.
But then I was free.
Now, nearly four years later, I think you could count on one hand the number of cigarettes I’ve had since — and that’s only because I can’t remember well enough to say I haven’t had any since I quit. I don’t remember any. You will occasionally find me standing by the smokers, wistfully wishing they wouldn’t taste horrible if I tried one, breathing in their smoke.
What does this have to do with programming?
Well — not a lot. But I think I told you that story to tell you this: there is always a way to accomplish something. Don’t let “it’s hard” stop you. Not get derailed because not all the options you want are present. Persist. I went to ridiculous lengths to quit smoking, because it was important enough to do so. Don’t let “can’t” stop you if it’s important. Find a way.
The long story
Needless to say, where I work we’re pretty serious when it comes to testing. We want not only to get it right, but to have it actually be right, and to have it give us the information we need to be able to make accurate decisions about our level of confidence in the code we produce.
Things are not always as they seem
The trick is — you don’t know that until you have gone too far. You’ll read things that say “Ok, install X, Y and Z with npm” and little do you know you’re already eating from the poisoned apple. If you are pulling your testing libraries (not support files, but the testing libraries themselves) you have already lost the war. First they get you to install Mocha and Chai with npm. Then you’re installing some abstraction layer that occupies globals.window to make your code think it’s running in a browser. This works right up until you start testing things that 100% expect to be running in a browser (like jQuery plugins). [Insert brick wall here.]
Testing code meant to run in a browser requires a browser
Now that we had a basis to work from, we needed to make sure we make sure we could use this specific setup with Jenkins, so we dug in and figured out that with only a minor change, we could also get it to output an XUnit formatted log file. Yay!
Now that we have the basics covered…
We’ve now hit our very basic bare minimum of acceptable tooling. We can write unit tests against any code we have, and run them in a CLI interface, quickly, to make sure we have not broken anything. Now we needed a way to make sure that we were writing unit tests against all of the code we had, so we would know that our changes hadn’t broken anything. [Maestro, cue the music for the great code coverage war, please...]
Well, to be fair, it wasn’t actually a war. Let me rewind. Before we had realized we were doing everything wrong yet again, we had already gotten code coverage instrumented with Istanbul. If you are doing code coverage in JS and haven’t looked at Istanbul, it’s about time you do. It provides an amazingly in-depth look at your code. Files, statement, branches, functions, and lines. This differs substantially to my experience with at least one other code coverage tool which we will talk about in a moment — I’ll get there, don’t worry. So we had Istanbul up and running, then we refactor everything to use PhantomJS and bam, code coverage is completely busted. Hacked and hacked to no avail, and then it dawned on me. Mocha (and by that virtue, Istanbul) was now running in the browser (ok, PhantomJS, but still…), which meant it could no longer write it’s data to the file system like it used to when we were running Mocha from the command line directly.
Needless to say, this made the chance of getting our wonderfully nice Istanbul coverage reports up and running again look a little bleak. Of course, at this point, we weren’t fully aware of how wonderfully nice Istanbul’s reports were. I took this opportunity to re-evaluate our tool selection for code coverage, and figured I would try out Blanket.js. It offered the promise of being simpler to instrument (no special step to modify the source code you want to coverage test), and you know, might actually work with our setup. Once we got it spun up I noticed something right away though: the coverage information was nowhere near as robust. Blanket.js offered just line based coverage information. Don’t get me wrong, line based coverage is better than no coverage, but I’d seen better. I wanted better. We had to have the better solution to solve this correctly.
We figured out that with a few little config changes we can make our test framework pull up the code we instrumented with Istanbul. It also turns out that that is about all Istanbul needs to “work”. Notice I said “work” and not work. We had code coverage running. We had the data. We could see it through DOM inspection when we loaded the test suite in our browser. Oh yeah! Did I forget to tell you that part? We could run ‘grunt test:browser’ and it opened our unit tests in our preferred browser for interactive unit testing! Now remember that browser bit, it’s about to come back to bite us in the. Come on, coverage data! Don’t be shy, come hide out on my hard drive where my tools can consume you. Maybe that didn’t help things — Anyway. So then someone (who is not me, and who will give me flack for not remembering they did it — I’ll come back and edit in the correct name of our brilliant genius once their name comes to light) figures out a way to pass the data back from the browser through PhantomJS to Grunt, and have it write said data to a file on the hard drive. Like I said, Genius.
And best of all
One of the things I learned very early on about working with a large team, is if you don’t make tasks as frictionless as possible, they have a tendency to not get done.
When we bought into using Behat as our functional testing framework of choice, it came with a mandate that when we install Behat, it cannot come from public sources. GitHub goes down. Repositories get updated. There have been instances of repos being compromised. We had to insulate ourselves from all of that risk. Fortunately, Composer has a GREAT tool for this, called Satis.
Satis provides you a way to create your own Packagist repository, complete with distributable tarballs of supported libraries. The one problem that I ran into (and this may have since been fixed? I’m not sure!) is that I couldn’t get it to download the dependencies of my dependencies. For example, your composer.json requires Package A which requires Package B. When I tried this, Satis would only build a repository with Package A. Knowing this would cause trouble down the line, I decided there had to be a way to make this simpler.
Out of that, Satis Repository Builder was born.
It will generate a Satis repository and upload it to S3 all with a single command. It’s still got some cleanup, but I realized that if I hadn’t done it in the last 4 months I wasn’t likely to do it in the next 4, and perhaps some feedback (or pull requests!) will spur some new life into my interest in it.
Once you have uploaded your repo, you can simply use the following setup in your composer.json to enforce pulling from your Satis repository:
That’s it! I’m sure there’s tons that can be done to the repo builder, and I look forward to seeing issues and pull requests!
One last piece of advice from the trenches
When you’re using a tool like this to decouple yourself from the risk of third party updates, be sure you are as specific as possible. List all of your dependencies and your dependencies dependencies, so when you do need to go back and upgrade a version of something, you control the scope of the update, not composer. The more specific you are in your composer.json about versions, the less variation you will see between builds of your satis repository.