Be The Lorax

I am the Lorax. I speak for the trees.

“The Lorax”, 1971

This was Dr. Seuss’ favorite of his books. If you haven’t come across it, it’s a great fable about a woodland creature who keeps warning an industrialist to stop cutting down all the Truffula trees; but the guy doesn’t listen and proceeds to destroy the ecosystem.

The Lorax book cover

From time to time I feel like the Lorax, but instead of the trees, I speak for the developers, who are every software company’s most precious resource1. And I think this is a crucial, but often overlooked part of the software manager’s job: litigation.

At times the plaintiff, other times the defendant, but usually in opposition to someone named Taylor from another department, like finance or HR, who doesn’t understand engineers. Sometimes Taylor is someone very high up, who used to be an engineer a lifetime ago, but they’ve forgotten what it’s like, now that their days are filled with meetings about sales projections and synergy. And here you come, Sr. Cat Herder, with a request to change the new dress code policy.

“You might not have heard, but we had a bit of a problem in Marketing, so we had to institute the dress code. We didn’t want to, but you know Legal.”

You see, Taylor’s not a villain. Almost nobody is. They’re just trying to do their best, and one thing people outside of Engineering are pretty bad at doing is putting themselves in an engineer’s shoes. It would be easier for most people to pretend they were a parakeet. But this is where you come in — you who have knowledge of the way of life in the dark cave of Engineering.

So you use your nerdy charm and wit to show that having a policy is fine, but that it just needs to be tweaked, because while the developers have no intention of causing problems, roughly half of them will quit before dressing “professionally” at work. And a third of those, have not worn long pants or closed toed shoes in years — and won’t start now. Not when they can get a good job by just whispering the words “I’m looking for a change” into the ether that’s continuously monitored by eager recruiters. Because as it turns out, those developers are a lot of the best ones we have, and they’re past putting up with well-intentioned policies. And if even one of them leaves, it’ll cost us a ton in recruiting, on-boarding, shipping delay, and general business risk, which is surely worth tweaking the policy to allow cargo shorts and sandals.

“But it’s 45°F outside!”, Taylor exclaims.
“It doesn’t matter, because they’re almost never outside,” you reply, and then continue with a whisper, “and they’re really stubborn.”

If you do this well, the policy will get tweaked before the developers are even told what was in the policy email they deleted, and the builds go on without a blip.

Sometimes you have to be the change you want to see in the company, which is a bit harder. Convincing the powers that be to allow flexible hours, or to get Engineering more expensive laptops, or that the savings were not worth switching to Microsoft Teams — these are the kinds of things that might need a Powerpoint. A beautiful, well-researched, entertaining Powerpoint, which will take a lot of your precious little coding time.

But these are the things you have to do as a good manager and the sacrifices you have to make, because you are the Lorax, and you speak for the devs. Though… hopefully better than the Lorax, in that you actually succeed in preventing the collapse of the ecosystem.

Footnote

  1. Just to be clear: I was using “resource” metaphorically. As much as nature abhors a vacuum, I abhor calling people resources. Trees and laptops and StackOverflow articles are resources — people are not.

Software & Opera, Part 3: Design & Test

This is the third and final part of a series on opera and software. Part 1 explained why they’re related, part 2 explained the development process used to produce an opera, and this part explores what can be applied to the software development process.

But first, the disclaimers: I’ve never worked backstage anywhere else, so I don’t know how other opera houses operate — they could be exactly the same, or wildly different. Also, everything in this article comes from my experience, and nothing is from Sarasota Opera — they don’t know I’m writing this (and hopefully, they’ll be pleased if they do ever come across it). Finally, what I do know of the production process comes from years of observation from the sidelines, from the role of a super, so some stuff in here could be just plain wrong; I’ll try to make it a point to underline where I know my knowledge is shaky, but there might be things I’m more sure about than I should be.

Let’s just dive in by recapping the operatic development process using software terms:

  1. The product manager writes functional specs (the libretto)
  2. The architect (composer) writes technical specs (the sheet music) based on the functional ones
  3. Management chooses a reasonable release date
  4. About a year before the release date, development begins on the infrastructure and wireframes (stage, sets, costumes), congruent to the functional and technical specs.
    • The infrastructure may well be sourced from elsewhere, or built in-house — whatever makes the most financial and artistic sense
  5. The main components (principal singers and stage management) are identified
  6. With roughly six months to go, the technical lead (conductor) learns the technical specs (sheet music) backwards and forwards and begins work on the main components (the principal singers)
    • The same as how, in software, the architect and the lead developer could be the same person so in opera, the composer and conductor could be the same person: Verdi conducted the first runs of all of his operas, and so have most composers. But after that first run, their operas are conducted just as well by other conductors.
  7. The UX designer (director) begins fleshing out the UI (choreography)
  8. Development begins on smaller components (auditions for smaller parts, chorus)
  9. Support infrastructure is stood up (props, rehearsal rooms, living arrangements)
  10. Management meticulously schedules acceptance testing (rehearsals), including bug fixing time.
  11. A couple of months before release, major development is done (the choreography, principal parts, sets, and costumes are all largely in order), the infrastructure is in place, and developer testing begins (all cast members rehearse at home)
  12. A month before release, developer testing is complete, and development is largely frozen: the infrastructure is ready, the entire cast is on site, and know their parts and music. Developer testing on the main components has been especially rigorous.
  13. Acceptance testing begins:
    1. The testing phase is the climax of the process. All hands are on deck, for very full days, for the duration.
    2. It takes place in a lightweight mock environment (the off-stage rehearsal room) with mock props and costumes
    3. The mock environment is designed to be easily reset and changed from one test to another, which is not the case for the production environment (the stage with sets)
    4. The architect, UX designer, developers, and management are all present
    5. Each workflow (scene) is thoroughly tested
    6. The testing harness supports starting from any point in a workflow, stopping at any point, and resetting to any point, so that the entire workflow doesn’t have to be run every time, making it possible to easily test every individual feature
    7. The testing harness supports various levels of integration testing, from interaction of only main components with mocked minor components, to full end-to-end testing
    8. Project management keeps track of each test’s outcome against the specs and design
    9. Project management files and tracks enhancement requests and bug reports (changes and corrections to choreography and singing) made by the developers and designers, who update specs and designs as needed
    10. The tech lead and UX designer make tweaks as needed and file bug reports, which are worked on with high urgency
    11. Once the tests are going acceptably well, testing moves from the mock environment and into a real one: the actual stage
    12. More enhancements and fixes are made until the UX designer and developer are happy with the outcome
    13. Beta users (coworkers, friends, early adopters) are brought in for final testing. There are very few, if any, surprises at this point.
  14. The product is released on opening night
  15. A point release or two may quickly follow, with minor changes (in the first couple of performances)

That should all be very familiar, but how does that differ from the process in most software shops? From my experience, it’s the beginning and the end: the design and the testing. Most shops focus on the middle: the development itself, with testing being a necessary evil, and design often being a quick drawing with some boxes and arrows, maybe just in someone’s head.

Don’t Focus on the Coding

The above process takes probably about 18 months, and the first half of it is all design. Main feature development takes about six months, and testing takes half of that again. So a full two-thirds of the process is design and testing — not development. On top of that, at the end of that six months of development, everything is already well-tested by the developers, with unit tests and rudimentary integration and functional tests. Which means that even less of that six months is actually spent on developing features; maybe as much as half that time. Counting that developer testing, we may be looking at nine months of design, three months of development, and six months of testing.

Design

At this point, you may be aghast at the idea of spending less than 20% of a release cycle coding, and 50% of it designing. The important thing to remember is that designing is programming. The difference is that it’s at a higher level, and it consumes almost all of the research time. It’s a more efficient, and more disciplined, approach than starting to code with only a vague plan, and changing direction as problems arise, pausing to learn new technologies, finding the right widget library, and then realizing that the protocol you started with doesn’t support one of your main features as you wrote it, which means going back to the drawing board.

That going back and re-coding, that’s what wastes a lot of time. That’s why the opera has so much design up-front and why a release date isn’t even chosen until the detailed design is complete, and thoroughly understood. And the opera is not alone, because every disciplined engineering profession does the same. I’ve never worked in civil engineering, but I’m pretty sure that every iron nail in a highway overpass is designed and placed before one worker arrives on site. A big design up front — not coming down a waterfall, but rather in a process that is flexible and agile — documented in great functional specs, is the hallmark of the timely and efficient building of anything.

When done well and thoroughly, it front-loads the vast majority of the variability. If you spend the first half of the cycle coming up with a great design, the last half should be an exercise in typing. The great screenwriter Aaron Sorkin said “You have to think about what you’re going to write before you write it”. Software works exactly the same way. The more specific and detailed your thinking, and the design document that comes out of that, the less surprises there will be in the development and testing phases.

This means the design should address gotchas head on: every technology used should be well-understood, it should be vetted to make sure it works like the architect thinks, and the design document should be as detailed as possible, with APIs, flowcharts, state machines and anything else that can reduce risk and variability in the second half of the cycle. Plus, that document should be very readable, and even entertaining, so that the variety of audiences that read it (devs, managers, QA, tech writers, etc) don’t fall asleep doing so.

If I’ve taken one thing away from my opera experience, is that it’s the important of a thorough design up front, in which literally every note is written before a singer is hired.

Testing

If there are two things I can take away from the opera, the second is definitely the outsized scope of testing. At the opera, testing is not only built into every part of the process — from design to development to release — but everyone is also laser-focused on it. Conductors play their music on the piano to make sure it doesn’t just sound good in their head. Singers practice for hours a day with coaches, who you can think of as the developers of singing. They essentially run unit tests all day long, making changes until the output (the voice) matches the spec that is the sheet music.

And once rehearsals start, everything falls in place, for the most part, with ease. There are always changes because a singer turned out to be taller than the director imagined, so he has to be placed further downstage; and three people in the chorus constantly put the emphasis on the wrong syllable of some Italian word they’ve never heard of, so the maestro has to explain Italian pronunciation yet again.

Enhancements and bugs are built into the acceptance testing phase, but they’re assumed to be minor. Easily changed and corrected, with relatively little effort from the developer. You don’t find out that the soprano can’t hit the high note at this stage, because she auditioned long before. You don’t find out that the set design is all wrong, because an intricate miniature replica was built first. If the main singer gets the flu, there’s a cover waiting to step in, having shadowed the singer at every rehearsal. Everything has been vetted, pre-tested, and every contingency addressed so that there are no show stoppers. Even without any changes at this phase, the opera would be good. The changes here are the little details that make it great: a flawless, amazing performance.

To get there, the testing has to happen in design and during development first. The acceptance testing has to involve all the roles in the production. And it has to be properly planned, with ample time scheduled for it, so that its success is the number one priority for everyone during that time.

Conclusion

By now, I’ve been to dozens of operas, many on opening nights, many in the audience and many backstage or on-stage, and I can count on one finger the number of major blunders I’ve experienced. It was about the fifth performance of a production of Turandot, when the king repeated the same line twice. People that weren’t paying attention to the Italian wouldn’t have even noticed, but someone else played the part the rest of the run.

I’ve seen many more small issues, like people dropping prop coins or papers, walking out the wrong exit, or forgetting to take a jacket off. But the lack of issues in general is astounding, to say nothing of the ability to release on time to the day, and on budget, year after year after year. All of that comes solely from the company’s ability to front-load risk, which then lets them plan the release with certainty, and devote ample time to testing and refactoring, so that the final product is an absolute gem.

Software & Opera, Part 2: The Operatic Development Process

This is the second of a three-part series on opera and software. Part 1 explained why they’re related, this explains the process used to produce an opera, and the last part explores what can be applied to the software development process.

Before I go any further, some disclaimers are in order: I’ve never worked backstage anywhere else, so I don’t know how other opera houses operate — they could be exactly the same, or wildly different. Also, everything in this article comes from my experience, and nothing is from Sarasota Opera — they don’t know I’m writing this (and hopefully, they’ll be pleased if they do ever come across it). Finally, what I do know of the production process comes from years of observation from the sidelines, from the role of a super, so some stuff in here could be just plain wrong; I’ll try to make it a point to underline where I know my knowledge is shaky, but there might be things I’m more sure about than I should be.

Pages from an 1859 libretto for Ernani

The stuff that happens early on is what I’m least sure about, because I generally start working on an opera during off-stage rehearsals, which is essentially the “acceptance testing” phase. But from what I’ve gathered, this is what happens before then:

  1. The libretto is written. This is like a movie script and contains the dialogue and stage direction. For most operas performed today, this was written long before your grandparents were born.
  2. The libretto is set to music. The composer takes the dialogue (and the gaps therein) and creates music that sounds nice to people who like operas. Again, this has usually been done at some point in the 1800s, but even for new operas, it would be at least somewhat before anything else happens. And now you have an opera — at least, on paper.
  3. The opera is slotted into a pre-existing Friday opening, about 18 months in the future. By the time one season starts, the next season’s roster of operas and their exact release dates have already been made public.
  4. Set and costume design are started. This is one of the longest phases, because a set may have to be created from scratch, and sets are big and can get complex. They actually take up most of the backstage area. Renting them is an option, if the size and shape of the stage is pretty standard. Costumes also may have to be made — sewn in the opera’s costume shop — but sourcing ready-made ones is time consuming too, since an opera with a full chorus and a bunch of settings could easily require over 50 costumes. And sizing is a thing to deal with on top of it all.
  5. About a year before opening, the principal singers and stage management are hired and contracted for the work, which actually starts some months later. There are usually about six principal singers and maybe a couple of more minor roles.
  6. The conductor starts learning the music and hires the orchestra.
  7. The director starts choreography design, figuring out what happens in each scene: where, when, and how people enter; what path they walk; how they act, what they physically do; and where, when, and how they exit the stage. Some of this is dictated by the libretto, but most is not.
  8. A couple of months later, general auditions take place for the chorus, which is about two dozen people.
  9. A few months before opening, props start to be created or sourced: swords, treasure chests, torches, faux violins. The set and costumes are done, but not tailored.
  10. The rehearsal schedule is completed — for two full months of rehearsals. Since four operas are being produced at the same time, only parts of each opera are rehearsed in each session (usually one particular act or scene), and rooms and the stage have to be scheduled so that rehearsals can happen in parallel. Also, the chorus usually appears in all four operas, so the scheduling has to take into account that they can’t be in two places at once.
  11. A couple of months before, the cast is all set and the various design work is mostly done. The cast starts rehearsing the music on their own.
  12. About one month before, the cast arrives on site (they come from all over the country, and internationally) and rehearsals actually begin.

This is the point where I enter. By the time of my first rehearsal, the principal actors have been rehearsing for weeks, and the larger chorus for some days. Principals have something like 10x the stage time as the chorus, so they have a lot more to work on.

The rehearsals early on are held in a large rehearsal room instead of the stage, to minimize labor costs associated with setting the stage. Instead, the floor of the room is marked with tape outlines of the sets, with different colors indicating different scenes. So Act 1 might be in red tape and outline some stairs and a couch, while Act 2 might be in blue tape and outline the same stairs, plus two doors and a table with chairs. When you rehearse Act 2, you walk around the blue tape and ignore the red tape.

There are generally a lot of new people, so everyone gets a name tag in the beginning. In each rehearsal, in addition to the performers, the conductor is present, along with a pianist, the director, a stage manager, and two assistant stage managers: one for stage left, one for stage right. Principals all get cover singers, to put the bus factor at 2, and their covers are also there.

Since the choreography is already designed by now, the director tells everyone what’s going to happen in the scene. No one is in costume, except principals might wear something a drunk person might think is their costume, to get used to walking around and singing with, say with a sword or a heavy coat. The singers have already memorized their music, and performed it in front of a maestro and gotten notes on what to change.

An important thing to understand is that everything in an opera is cued by music, and the music is cued by the maestro. She moves her baton at a certain tempo, and all of the singers and orchestra musicians keep that tempo. When she stops, they stop and when she starts, they start. If they start to lead or lag her, she stops and yells at them. “Can everyone see me? Can you, Jeremy? Because if you can, why are you half a measure behind?” The conductor is essentially the system clock, for a multi-processor system. Or maybe an NTP server.

Because of this, the cast’s actions are also cued by the music and it follows that the director’s directions are usually given relative to some piece of music: “when Isabella gasps, you three move upstage, and you go put your hand on her shoulder. Then, on the beat after ‘da dada da dun’ everyone but the Don exits the stage. Ok, let’s take it from two bars past 62”. It’s amazing to me that the singers can start from any part of the entire opera, with a second’s notice.

Stage management keeps a giant binder with the sheet music for every role and marks where in it things are supposed to happen — like stage entrances and exits. After everyone verbally understands what’s supposed to happen, we run that part of the scene, with piano music. Here usually, someone omits doing something — walking somewhere, facing someone, fake laughing — something got forgotten or misunderstood in the space from the director’s mouth to the cast, so we reset and run again. Sometimes, the director, having seen it run with actual people, decides to change where people stand or face or who they fake banter with, so we reset and run again. Later, when we rehearse on stage with the actual set, sometimes things are tweaked even more. And if the singing is off, the maestro stops the music, yells admonishments, we reset and run again.

Once the director and maestro are happy with the way things are running, they layer in any additional people in another rehearsal. For example, sometimes we have rehearsals just with the supers, or the supers and chorus but not principals, for various scheduling reasons. And when everyone knows their parts well enough, they’re all brought in to the same rehearsals.

The off-stage rehearsals are generally splayed over three weeks, with each scene being rehearsed about three times, depending on the complexity. Once in a rare while, things might be going so poorly that they might add rehearsals; as an unpaid volunteer doing this for 20 hours a week on top of your day job, that’s what you really don’t want.

Finally, it’s about three weeks before opening, and we get to rehearse on-stage! There are only a handful of rehearsals left at this point, but most of them are of the entire opera, start to finish:

  1. A couple of rehearsals with only the piano accompaniment still
  2. A piano dress rehearsal — meaning still only the piano, but full costumes for everyone, though only principals get makeup
  3. A rehearsal with the orchestra but no costumes
  4. Finally two full dress rehearsals with the orchestra.
    • These last two are run exactly as if they were live performances, with beta testing users being brought into the audience, in the form of friends, family, and big shot donors.

During these on-stage rehearsals, the lighting people are also testing the colors and intensities to make sure they create the proper environment and mood, the costume and makeup designers check to make sure everything looks good from the audience, and the director walks around the whole opera house to make sure various vantage points can all clearly see the important action.

For the last rehearsal, they generally bring in a couple of classes of middle or high school students, and again: they’re run exactly as they will be on opening night, with PA announcements, supertitles, intermissions, curtains, etc. — even the bows at the end are rehearsed. The only differences with respect to a real performance is that the conductor might still stop the music if things are going too wrongly, she gives notes to the orchestra at the beginning of each act, and the director hovers around the whole house looking for final tweaks to make.

After opening night, things are mostly on rails. The director might issue notes with small things the cast is doing wrong or she’d like to change, someone might need musical coaching if they’re too loud or soft or whatever, but by and large everything is set at that point, and it all just manifests like a clockwork for a dozen performances. That is actually the inflection point for when it gets really boring. After the jitters of opening night, it all becomes so routine that there’s not much excitement in it anymore — but that’s good, because then you can finally focus on the performance.

In the next and final part, we’re going to talk about how all of this applies to software development.

Next: Software & Opera, 33 1/3

Software & Opera, Part 1: The Music, Not The Browser

Over the past decade, I’ve done eight seasons with the Sarasota Opera. The usual reaction I get is either “Wow, I didn’t know you could sing!” or “I could totally see you as an opera singer!” I’m never quite sure if that second one is meant to be a compliment, but in either case: I can’t hold on to a note any better than to a cat. So instead of a Pavarotti-type, I’m what’s called a supernumerary, which is Latin for “extra numbers” — a non-singing extra, normally just shortened to “super”. (Because I’m male, they usually refer to me as a “super man”, which is awesome.) Also, Sarasota Opera is a very professional house — which is actually the reason for this essay — and only hires phenomenally qualified singers, who’ve formally trained for years. I, on the other hand, still haven’t figured out what a “clef” really does.

My parts are usually some kind of guard or soldier off in the background, my only reason for existence being to underline the importance of other people by escorting them on and off stage — or because they’re prisoners. Sometimes the parts are beefier, like a very cool executioner in the degradation scene in Jérusalem, or a nimble thief that scales the wall to kidnap Gilda in Rigoletto. My last role was a guy in a band in La Wally, faux-playing a faux-violin on top of a table, while trying to keep time with the actual violins in the orchestra pit, during a lively party that, of course, ends in disaster.

La Scala of Milan

At this point, you might be thinking “this is neat and all, but what does it have to do with software?” — and that’s a perfectly valid thought. The answer is that over these long years, I’ve noticed some very interesting parallels between the production of an opera and the production of software.  From my first day there back in 2010, Sarasota Opera amazed me with its clockwork precision, streamlined efficiency, and amazing courtesy and professionalism toward everyone, from principal singers, to lowly supers. And every year but this one, they deliver five operas: all on-time (same Friday every year), all impeccably sung, directed, and designed, generally getting great reviews, and involving a crew of several dozen people over a timeline of more than a year.

Can the average software company make the same claim? Apple and Google can: iOS and Android are released on a yearly cadence, like clockwork, and for the most part, they are masterful works with serious bugs being rare. However, in my experience, most other software releases are late and buggy. They’re probably buggy because they’re late and were rushed out the door, and they’re late because things didn’t go according to plan. So how does the opera — in essence a small, non-profit business — stay on plan and deliver such consistent and high quality results? What parts of that are and aren’t applicable to software development? And how much does the operatic world even have in common with that of software?

To answer the last question first, a lot:

  1. Both follow the same process: design, development, testing, narrow release, wide release
  2. Both produce highly technical works of art. Music, orchestration, choreography, and stage production are all, of course, highly technical. And if you don’t think software is a work of art, just think about how important good design is to user adoption.
  3. Both have audiences that are intolerant of bugs
  4. Both are staffed by highly trained professionals
  5. Both have administrative staff managing “the talent“, plus support staff making everything actually work.
  6. Both have the same constraints: deadlines, budgets and headcounts
  7. Both require a great deal of planning and design in order to be done well
  8. Both have a number of specialized departments that work in concert (pun intended): developers, testers, DevOps, ProdOps, UX, and product management on one side vs singers, orchestra, props, costumes, makeup, lighting, set design, and stage hand, on the other.
  9. Both have hundreds of components interacting with each other, even in parallel. Opera is generally massively parallel, especially if counting the orchestra.
  10. Both are run from compiled code: musical notation is conceptually the same thing as binary code, with each singer or musician being the processor that executes the instructions for their particular role

There are more, but ten is a nice round number. And hopefully the reason this essay exists makes more sense now. If you’re still keen, the next part talks about how an opera is produced and finally in the third part, what can be applied to the software development process — which is that projects should focus on design and testing, rather than coding. Oh wait… did that just spoil the ending? Because if not, you should also know that the other two parts are much longer, too.

Next: Software & Opera, Part Deux

Two More Annoying iOS 11 Bugs

So far, iOS 11 is maybe the buggiest release Apple has put out: it’s had eight updates to fix a bunch of issues, like the infamous A ⍰ bug, and while you’d think they’d have ironed most serious things out by now (11.2.1), I ran into two more, and verified them with Apple support on the phone.

I’m posting them here because I scoured the Internet for answers on them and got nowhere, which is why I resorted talking to Apple on the actual phone, and hopefully this will help you avoid doing the same thing. I’ll also update this post if and when they get fixed.

Bug the First: Edit and Share buttons are grayed out on some photos

This one is straightforward and super annoying and mind boggling: I can’t edit or share some small minority of photos. There seems to be no rhyme or reason as to which photos. The guy I talked to Apple couldn’t find the issue in their database, even though there’s at least one thread on it on discussions.apple.com (though it’s been erroneously closed).

Workaround: import the photo into an app that’ll let you re-save it. I used Camera+.

Bug the Second: On the first iCloud backup, you can’t choose what to (not) back up

Let’s say you have 5GB of Photos and you wanna do an iCloud backup of just the phone settings, because the photos are backed up already in some other way, and you got a new phone that you want to transfer your settings to. The settings themselves should be around 200MB.

Assuming you haven’t wasted money on iCloud and your limit is still 5GB, even if you have nothing in iCloud, when you turn on Backup it tells you there’s not enough space in iCloud, because it’s trying to upload your photos also.

Image result for ios 11 this iphone cannot be backed up because there is not enough icloud storage available

That’s it: you’re stuck. There is no way to get past this without buying more iCloud space.

In previous versions of iOS, you could switch off Photos, for instance, as well as iMessage and everything else, so you didn’t end up uploading the entire phone’s contents to the cloud. And you can still do this, on a backup-by-backup basis, but only — and this is the maddening part — if you already have a backup in iCloud.

Otherwise, there’s no way to control what goes up there or even see what the Next Backup Size will be.

Image result for ios 11 choose what to backup

Choosing what to back up was so easy in iOS 10, and I was so incredulous that it wasn’t in iOS 11, that I went to the Apple Store so they could show me what pathway I was missing. After that went nowhere, I brought it up with the guy on the phone, and he confirmed this is how things are now.

There’s a StackExchange question out about this, but the problem seems to be too nuanced to have made it onto Apple’s radar.

Workaround: use an iTunes backup to restore the settings onto the new phone.

I’ll update this post if and when these things get fixed.

Home Theater Setup 2016

I love big screens and I cannot lie. My first major purchase after I got my first professional job was a projector. My first major purchase after I got my first house was a new projector. And I got an even newer projector late in 2015. With it came a refresh of the whole setup.

This is now my third projection system, and after a lot of research, I feel like it’s the first that’s actually set up really well. The first projector wasn’t 1080p and I didn’t even have as much of a screen as a really uniform white wall, so… not a great setup. The second generation was a big improvement, but I didn’t do any calculations and so some people thought the screen was too big to watch from the couch. Either due to finally applying the maths, or because the third time’s a charm, this version 3.0 is very much on point, and so this post lays out what I did in excruciating detail, because good documentation is the cornerstone of process improvement.

TL;DR: I put an Epson PowerLite Home Cinema 5030UB on an OmniMount wall shelf 11′ away from a 110″ Elite Screens SK110XHW-E24. There’s VIZIO S5451w-C2 soundbar behind the screen, a Monoprice 40′ active HDMI cable going through the ceiling from an outlet to the soundbar, and another from the soundbar to the projector. Into the outlet, I usually plug in an AppleTV 4, but sometimes I plug in my PC. And because the soundbar is behind the screen, there’s a BAFX IR Repeater with the IR receiver on the screen housing, and the emitter behind it.

Total equipment cost in 2016 dollars: 3250$

Absolutely _not_ my home theater system

The Screen

I had to start with the screen because the projector needed to go into a family room attached to an open kitchen, which limited me to two walls of roughly the same size. The room itself is 11′ square, but in the direction that goes into the kitchen, the projector can go back as far as my wife would let me, which was about 15′, so that “it’s not actually in the kitchen, you know?”.

However, the bigger concern was brightness. The room is not very well light-controlled, and I need to be able to watch certain things — like football games — in the daytime. (The further back a projector is, the less bright it will be on the screen). We also have a TV facing out toward the kitchen, so putting the projector on the other wall would limit me to 11′ projection distance, but allow me to have both TV and projector running at the same time, as opposed to the screen covering the TV when it’s down. And you know what that means: simultaneous viewing of both NBC and CBS election coverage this past year. Oooooh yeah.

With the wall picked out, I calculated the screen size to buy: 11′ is 132″, and THX recommends screen sizes be 0.84 of the viewing distance, which works out to 110″ screen. (If you subtract the length of the projector itself, it works out more to like 100″, but I like screens being a bit on “bigly” side.)

For vertical placement there are two general guidelines:

  1. A rule of thumb that the bottom third of the screen should be below the viewer’s eyes, which are generally at 38″ for a seated adult
  2. That the top of the screen should be no more than 15 degrees above the viewer

For a 110″ screen, which has a height of 54″, the one-third that’s supposed to be below the viewer’s eyes is 18″. That leaves 36″ above the viewer’s eyes, and at an 11′ viewing distance, the top of that screen would be 15.3 degrees above the viewer, so that works out perfectly.

Screens generally have a 2″ black border all around, so that makes the entire screen 58″ tall, and brings the one-third that’s below the eyes to 20″. If the eyes are at 38″, that means the screen’s bottom edge is 18″ off the floor, and the top edge is 76″ off the floor. Unfortunately for me, there was a 96″ tall door frame on part of that wall, so I had to get a screen that had an additional 24″ of black border at the top, so I could essentially hang the housing up that much higher than where the actual white part of the screen needed to be.

With that added requirement, basically the only option I had was the the Elite Screens SK110XHW-E24 for 460$, which was a 110″ screen with 1.1 gain and 24″ drop. I’m not sure if I’d know a bad screen if I saw one, aside from obvious flaws, but I definitely don’t mind this one, and it goes up and down like a champ.

The Projector

Once I had the screen picked out, I started looking at the projectors rated highly on projectorcentral.com. Three stood out:

  1. Sony VPL-HW40ES – 2500$, editor’s choice for 2014
    • According to its calculator, for a 110″ screen with gain of 1.1, placing it at 16′ away would mean using a 1.07x zoom and the image brightness would be 20fL; 13’9″ for 22fL, 11’10” for 24fL
  2. Panasonic PT-AE8000 – 1850$, editor’s choice for 2015
    • According to its calculator, for a 110″ screen with gain of 1.1, placing it at 14’10” away would mean using a 1.47x zoom and the image brightness would be 20fL; 13’9″ for 22fL, 13’1″ for 24fL
  3. Epson PowerLite Home Cinema 5030UB – 2300$, editor’s choice for 2013
    1. According to its calculator, for a 110″ screen with gain of 1.1, placing it at 16’4″ away would mean using a 1.41x zoom and the image brightness would be 20fL; 15′ for 22fL, 13’9″ for 24fL

After some internal debate, as you may have read above, I went with the Epson, for a few reasons:

  1. I liked the previous Epson PowerLite Home Cinema 6100 I had
  2. It had the most reviews of any of these on Amazon (139 reviews, 4.5 stars)
  3. Great zoom and brightness

I also looked at the 5030UBe, which has the interesting wireless HDMI feature, but apparently it has connectivity issues, especially with gaming, so it’s not worth the extra price tag if you can’t reliably use it.

The Speakers

One of the great problems with front projection systems — if not the greatest — is sound. The virtually universal advice is that you need to get a good receiver, run all sound through that, and just run an HDMI output from the receiver to the projector.

Well, I’m a minimalist, I only have two inputs for the big screen (Apple TV and my PC), I’m not an audiophile by any means (stock TV speakers sound great to me) and on a philosophical note, I absolutely will not buy yet another gadget to make up for the fact that projector manufacturers just can’t seem to bring themselves to make simple Audio Out ports be a thing on their devices.

Throw in the annoyance of running speaker wire, and when I saw a well-reviewed Vizio soundbar on sale, and it had wireless speakers, I bought it. It’s the 2014 model, so it was old when I got it, and not even available new anymore. But, I love it.

At first, in an effort to avoid a run of cabling, I tried to have HDMI only go to the projector and to get the audio to the soundbar via Bluetooth from my AppleTV and my PC. But while music worked fine, video absolutely did not: the last syllable to many words would get dropped out, and it was just unwatchable. So I regrouped and ran HDMI to the soundbar and then another HDMI cable from the soundbar to the projector. The soundbar picks off the audio and sends the video to the projector, which means I just have two HDMI cables running through the walls and ceiling and it works beautifully.

The subwoofer is wireless and hangs out hidden away in the TV stand. Two wires come out of the back of the stand and go behind the couch and up to the rear speakers.

The Accessories

HDMI

For the first leg, from outlet to soundbar, I needed a 40′ cable, which meant I needed an active one, that deals with attenuation over that long of a haul. Monoprice is where I usually get cables, and this was no exception: they have 40′ active HDMI cables for 35$ and after one year, I have zero complaints. But do note that they are unidirectional: you have to have the right end in the soundbar or projector. I got two of these, one for each leg.

Now, a word about installation: for my second generation system, I waited for a cool November day, ran the cables in the ceiling myself, and I have the scars to prove it. Literally: I sliced my knee on an exposed bracket in the attic to what seemed like the bone, and had to superglue it shut (to avoid going to the ER and having them do the same). For this third generation, I was going to repeat history. Then I realized that due to the position of the soundbar in the house, I couldn’t even figure out how to physically get a cable there, much less how to stay conscious for that long in the Florida heat, that in an attic, approaches Venus conditions. So I hired a professional home theater outfit and both cringed and thanked the seven gods while seeing what they went through. Worth every penny.

Infrared

Second, in an effort to make things look nice, I mounted the soundbar behind the screen. I already had to mount the screen housing about a foot off the wall, so that the screen would drop over a set of drapes, so I had clearance back there. And really, I had nowhere else to put the thing. To my great dismay though, on testing, I found out that with the screen down, the infrared from the soundbar remote control would only work if I walked over and pointed it behind the screen and up to the soundbar. Which really sucks to do when you’re trying to enjoy a movie but it gets loud enough to wake the baby — and the baby is literally the last person you want waking up when you’re trying to enjoy a movie.

To get around this, I bought a BAFX IR repeater for 28$. You stick a small IR receiver on the projector screen housing, plug that into a box that’s mounted and hidden behind the housing, and then plug in an IR emitter that points to the soundbar. Boom! You’re now a light bender.

This particular gadget is a little overkill for this purpose because it could control up to 8 devices and I just needed one, but I couldn’t find anything good for less money anyway.

The repeater is _not_ pretty

Future Improvements

So that’s it for now: pretty simple setup, great results, mostly thanks to the calculations and planning. But nothing’s ever perfect, so while I’m happy with version 3.0 of the Jiva Projection System, I’m definitely planning on upgrading to 3.1 and 3.2 when I “get the time”.

First, I’d really like to actually mount the rear speakers up on the wall someday. Right now, they’re just on the floor behind the couch. Honestly, this is because (again, I’m the opposite of an audiophile) I find them more distracting than anything. Whenever I hear a distinct “rear” sound, I don’t think “oh wow, how realistic”, but more “WTF was that noise?!”. Which means that a lot of the time, surround sound is just off. But, maybe it’s like beer and I just have to acquire a taste for it so I can hang with the cool kids.

Second, I really need to put a power outlet behind the projector. There’s an HDMI outlet there that the nice home theater people put in, but they weren’t licensed enough to run power behind the wall. So now there’s this power cord that just runs down the wall, that a toddler can and would definitely like to tug on. And yeah, I could just drill two holes in the drywall and run the power cable behind it, but that’s not up to fire code, and insurance is a bitch. So I’m currently trying to either work up to running high voltage wire myself, or getting an electrician to do it. And I really don’t want to do the latter, because while delegating is par for the course at work, actually doing stuff is what makes me wake up in the morning.

Third, I probably should get a fancy Harmony remote, because between the projector, soundbar, TV, cable box, Apple TV and homemade DVR, we literally have half a dozen remotes. But, 95% of the time, the Apple TV remote is the only one we use. And I just can’t bring myself to spend 150$ or more on something that’ll get used once a week and only very marginally improve my life. But, I’m keeping it on the backburner as a birthday wishlist item, for when I become the man who has everything, so that I don’t wake up to find myself entombed alive in a cemetery in Mexico.

Setting Up Ubuntu For Android Development, 2015 Edition

At work I use a MacBook Pro because that’s what they give us. At home, my desktop is Windows because of Windows Media Center and gaming, but I also recently rescued a Dell laptop that now has Ubuntu on it. While setting up that laptop for Android development, I ran into a couple of gotchas and found some shortcuts; so when I set up a new VM for a new project on my desktop, I decided to document the steps for reference.

To wit, at the end of the following procedure, we’ll have Android Studio running on Ubuntu 14.04.3 (Tired Trampoline) on VirtualBox 5.0.10. If you need a lighter VM, these instructions also work with Lubuntu.

  1. Download VirtualBox (for this guide, 5.0.10), if you don’t have it
  2. Set up a new VM
  3. Download the Ubuntu Desktop ISO (for this guide, 14.04.03)
  4. Load it into the VM’s optical drive, boot up the VM, and start the install
  5. After answering the setup questions in the beginning, go watch TV for a while
  6. When it’s done, eject the install ISO from the VM and reboot
  7. It’ll boot up in glorious 640×480 mode; insert the Guest Additions CD image, to do stuff like allow you to use a decent desktop resolution:
    VirtualBox Guest additions disc

    • A dialog will come up allowing you to automatically run the script on the disk, but if something goes awry, open a terminal, go to the disk and manually run the script:
      cd /media/{username}/VBOXADDITIONS*
      sudo ./VBoxLinuxAdditions.run
      
  8. Reboot the VM
  9. Change the display resolution to something sane (System Settings -> Displays)
  10. If the Unity side taskbar annoys you too, make it auto-hide (System Settings -> Appearance -> Behavior; enable workspaces too) and install Cairo dock:
    sudo apt-get install cairo-dock
  11. Install Oracle the Java 8 JDK — not OpenJDK, because AndroidStudio doesn’t like that as much. You can do this easily thanks to the WebUpd8 team:
    sudo apt-add-repository ppa:webupd8team/java
    sudo apt-get update
    sudo apt-get install oracle-java8-installer
  12. If you’re running 64-bit Ubuntu, you’ll need to install a couple of 32-bit libraries the Android SDK needs to avoid the Unable to run mksdcard SDK tool” error:
    sudo apt-get install lib32z1 lib32ncurses5 lib32bz2-1.0 lib32stdc++6
  13. Install Android Studio from Paolo Ratolo’s repo:
    sudo apt-add-repository ppa:paolorotolo/android-studio 
    sudo apt-get update 
    sudo apt-get install android-studio
  14. Run Android Studio and add it to the launcher:
    /opt/android-studio/bin/studio.sh
  15. If you need to, install git
    sudo apt-get install git

25 Tricks To Appear Smart In Emails And Meetings

Sarah Cooper is now a freelance designer and writes The Cooper Review, but before that, she worked as a designer at Yahoo! and Google. Clearly, the years she put in there have given her plenty of ammunition for tech satire, because at least three of her listicles are hilariously spot on. They include such gems as:

  • Using a “sent from mobile” signature even from your laptop, to appear busier
  • Answering unimportant emails or ones from important people right away
  • The use of nerd language like “orthogonal”, TL;DR and other acronyms
  • Encouraging everyone to take a step back
  • Asking presenters to back up a slide
  • Taking important phone calls in meetings
  • The importance of making fun of product managers

All these tips and more, conveniently available in poster form:

Bonuses Don’t Motivate Developers

First, let me reassure you that they don’t: 50 years of research have shown us that if anything, incentives demotivate employees. And not just developers, but any job that requires some thought beyond mechanistic, rote work like the assembly line.

This is succinctly explained in the most popular RSA Animate video so far (you can watch it below) — a speech given by Dan Pink, who literally wrote the book on motivation. In it, he explains how an experiment funded by the Federal Reserve and conducted by MIT, Carnegie Mellon and the University of Chicago showed that bonuses led to poorer performance for any tasks that required anything above “rudimentary cognitive skill”.

Increasing the bonuses didn’t just not do anything, it actually made people perform worse, and it held true for populations both in the US and in rural India. But this hugely valuable research is mostly ignored, despite being basically ancient by now:

  • Herbert Mayer wrote in a 1975 paper that

    “…  merit pay emphasizes the direct relationship between job performance and dollar rewards, thereby detracting from intrinsic motivation in the work itself. A system that would switch the emphasis to rewards for self-development and opportunities for greater responsibility would seem to serve both individual and organizational goals in a more effective manner.”

  • Alfie Kohn, author of another book on motivation, wrote in a Harvard Business Review article in 1993:

    “As for productivity, at least two dozen studies over the last three decades have conclusively shown that people who expect to receive a reward for completing a task or for doing that task successfully simply do not perform as well as those who expect no reward at all. “

  • Joel Spolsky, after quoting the above, wrote in 2000:

    “… any kind of workplace competition, any scheme of rewards and punishments, and even the old fashion trick of ‘catching people doing something right and rewarding them,’ all do more harm than good. Giving somebody positive reinforcement (such as stupid company ceremonies where people get plaques) implies that they only did it for the lucite plaque; it implies that they are not independent enough to work unless they are going to get a cookie; and it’s insulting and demeaning.”

  • Joel again, in 2006, writing about what he calls the “Econ 101 Management Method“:

    “But when you offer people money to do things that they wanted to do, anyway, they suffer from something called the Overjustification Effect. “I must be writing bug-free code because I like the money I get for it,” they think, and the extrinsic motivation displaces the intrinsic motivation. Since extrinsic motivation is a much weaker effect, the net result is that you’ve actually reduced their desire to do a good job. When you stop paying the bonus, or when they decide they don’t care that much about the money, they no longer think that they care about bug free code.”

So the rule is that money does not motivate, with two caveats:

  1. Rote, mechanistic tasks: more money works beautifully in that specific case. Which is why we have bonuses at all, because it worked so well in the factories where Henry Ford pioneered the concept of paying workers a better wage for better performance.
  2. Too little money: if workers think they’re not being paid fairly, it becomes a sticking point and all they think about is how they’re being screwed, which obviously prevents them from performing at their full potential.

Joel had another article in 2006, called “Identity Management Method“, in which he described how to create intrinsic motivation:

“To be an Identity Method manager, you have to summon all the social skills you have to make your employees identify with the goals of the organization, so that they are highly motivated, then you need to give them the information they need to steer in the right direction.”

Fast forward to Dan Pink’s 2009 book and 2010 RSA Animate, and he continues the same idea, breaking it down into three factors that do increase performance:

  1. Autonomy: as a manager, giving your employees autonomy is the best way to get them engaged in the work. He mentions Atlassian’s ShipIt Days as an example of how autonomy leads to great things, and should’ve mentioned Google’s 20% time as well.
  2. Mastery: “the urge to get better at stuff”. This is a big reason why the open source movement exists.
  3. Purpose: an important reason to do what you’re doing. The open source movement ties in here, and also crowd sourced efforts like Wikipedia, but increasingly, companies: Apple, Google, Facebook all have self-invented lofty purposes for their existence, and this inspires their employees.

Bonuses are related to none of those. The only reason to ever dangle bonuses in front of developers, is maybe as compensation for the rare big push requiring lots of overtime; and in that case, it’s just to prevent them from feeling exploited. Otherwise, bonuses will actually hurt productivity. And that’s a scientific fact. To get better performance out of your employees, hire smart people and let them be smart. Tell them the company story and why the job is important, then simply get out of the way and help them when they need it.

Why Great Functional Specs Are So Important

Way back in the year 2000, the venerable Joel Spolsky wrote a blog post called Painless Functional Specifications – Part 1: Why Bother? It was the first of a four-part series on writing functional specs, and it featured a tale of two software companies: Hasty Bananas Software (HBS) and The Well-Tempered Software Company, a.k.a WellTemperSoft (WTS). Guess which one’s the good one. They both work on the same task of writing a file converter, but WTS does it with a spec and HBS does it without one. Contrived results? Sure:

Total elapsed time for Mr. Rogers [at WTS]: 3 weeks and 1 hour. Elapsed time for Speedy [at HBS]: 4 weeks, but Speedy’s code is not as good.

The story had two morals: functional specs lead to better software design, and they save time communicating:

When you write a spec, you only have to communicate how the program is supposed to work once. Everybody on the team can just read the spec. The QA people read it so that they know how the program is supposed to work and they know what to test for. The marketing people use it to write their vague vaporware white papers to throw up on the web site about products that haven’t been created yet. The business development people misread it to spin weird fantasies about how the product will cure baldness and warts and stuff, but it gets investors, so that’s OK. The developers read it so that they know what code to write. The customers read it to make sure the developers are building a product that they would want to pay for. The technical writers read it and write a nice manual (that gets lost or thrown away, but that’s a different story). The managers read it so that they can look like they know what’s going on in management meetings. And so on.

When you don’t have a spec, all this communication still happens,because it has to, but it happens ad hoc.

Fourteen years later, there came a company called Sprintly, which makes agile project management software. They have a lot of data on how long developer tasks spend in the various stages of the task lifecycle, so they wrote a blog post about it. Turns out, bad functional specs waste a lot of time communicating:

… most of the variability occurs before a ticket has been started (Someday to Backlog). This is the stage when stakeholders are figuring out specs and prioritizing work.

From Sprintly

From Sprintly

In the graph above, the middle two states are when coding is being done. The first and last state are when people are arguing about the specs.

First, Business Bob writes something like “As a human, I want to look at cat videos, so that I’m distracted from writing specs”. Maybe he adds in something about how the videos should play on a mobile phone and not stop to buffer every three seconds. Satisfied with his thoroughness, he emails it to Developer Dave who promptly files it away. Six weeks later he’s ready to tackle the Cat Videos feature, pulls up the spec and realizes it’s so vague that he has no idea where to start. So Dave walks over to Bob’s desk and asks 52 questions:

  1. What format should the videos be in?
  2. Do we want to support multiple bitrates?
  3. Is doing it in HTML5 in the browser fine, or do we have to do Flash too?
  4. Are we hosting these cat videos?
  5. Are we supporting portrait mode on mobile devices?

52. Are we transcoding videos on the fly, or offline?

Business Bob now cringes, realizing what hell he’s gotten himself into, trying to remember why he even wanted the cat videos, and spends the next two days coming up with some decent answers. Except Dave now has follow-ups to those, like what the server hardware specs are gonna be for the video hosts. This goes on for a few more iterations, and Dave finally has a decent spec, so he codes up a storm, then hands it to QA.

Two more weeks later, Tester Tricia pulls up the spec (if you’re following along, we’re now in the last state in the graph above) and takes her turn to terrorize Business Bob:

  1. Should the user be allowed to use multi-touch in the mobile version?
  2. Can the user switch bitrates while playing the video?
  3. Is there a limit on the number of cat videos that can be stored?
  4. What versions of what browsers should be supported?
  5. Are dog videos allowed?

52. What is considered an unacceptable transcoding time?

This is why we can’t have nice things. If Dave did a great job reading Bob’s mind and covered all the bases, maybe the software will pass QA without defects being written against requirements that were changed after the software was written. Sprintly’s data backs up what Joel was saying long ago: unclear and changing requirements eat up developers’ time.

This is why we need great — not good but great — functional specs. It is likely the biggest efficiency gain any software process can make for the cost of a talented spec writer. And that’s key, because that writer will be hard to find.

They need to be technical, ideally have experience writing software (so they know what it’s like to need good specs, and what they entail), be very thorough, detail-oriented, be able to take a lot of criticism, be able to build consensus, to get input and sign-offs from all stakeholders, and most importantly, be a solid writer. Make those specs fun to read, because boring specs make people fall asleep and that’s not good for business.

The last point Sprintly makes is how expensive context switches are, and they link to another classic post by Joel. Turns out that lead developers, who switch contexts a lot, are at least twice as slow at finishing tasks as other developers. So throw out those daily meetings, make coding hours a sacred part of the work day, encourage sparse checking of email, and leave IM chatter for urgent business.

Spolsky must feel like Einstein after Pound-Rebka. Though, more alive.

From Sprintly and Joel on Software, via Slashdot