Sometimes the little things aren’t so little

In my last post, I gave myself and all the devs a beating for being passive-aggressive about marketing-driven name and terminology changes.  For not being-with-the-program when the product team wanted to make an itty-bitty change they’re entirely within their right to make.  In thinking back over some of those types of situations, there was really only one good reason for being a dick about that stuff – when we had the old name embedded in the source code of the product itself.

babynamesLet’s say we have a product called BottleRocket.  Well, then we probably have a java package named com.pointyhairedstartup.bottlerocket.  Then let’s say we rename the product to Kite.  Okay, renaming a package is no big deal.  We probably also have a class named BottleRocketMain.java.  Again, renaming a class isn’t a big deal.  But maybe it’s a webapp and we have a war file called BottleRocket.war.  Ooh, that’s a little uglier, because that means we have URLs calling https://pointyhairedstartup.com/BottleRocket.  And the tools for refactoring URLs within a project are not as good as the ones for refactoring class names.  And URLs are also abused – called willy-nilly from wherever someone who wants to call it can jam a hard-coded URL in.  They live in config files or are constructed dynamically in ways that are hard to detect.  And you won’t catch them in the build like a bad class name.  You’ll catch them at run-time, when some sad little user clicks a dynamically constructed URL that has the old name in it.  If you’re lucky, you have tests that exercise the URLs.  If you’re lucky.

So you rename the war file, march with the new URL and alias the old URL to the new one, which adds inexplicable cruft to your web configuration.  Two years from now, the new guy will delete the alias as being nonsensical (WTF is a BottleRocket?) and of course end up breaking something that nobody knows how to debug.

And of course no product is useful without a database, and databases need names so we have a database named BottleRocket.  Hmmm, this is a tough one.  Having a DB with a legacy product name isn’t THAT bad.  But it’s not good either.  But doing a database upgrade is ugly and dangerous, so doing it just for the DB name doesn’t make sense.

Wow says the product guy, this is way more complicated than it looked.  But let’s make it really ugly.  We’ve decided to go full touchy-feely because that’s what marketing is all about and now we refer to our users not as “customers” but “guests”.   Well that’s good for our customers … er guests … but guess what?  We have a table in the DB named “customer”.  And as I said before, database upgrades are ugly and dangerous.  But table names are different than database names.  If you don’t rename that table then engineering will always call users “customers” and they’ll have every right.  At the same time, they’ll have every right to bitch you out about doing a DB upgrade to change a table name.  One of the perks of being a dev – you can look down on product guys because situations like this prove that God does not love them.

It gets worse.  There are probably references to “customer” all over the code, in field prompts, embedded in graphic assets … If you’ve been good about your strings, that refactor is probably safe (unless you’re localized), but the graphics are another problem altogether.  Somebody has to own verifying the assets.  Shitty job.  And remember Mister Product, you’re doing all this work and getting not even one little bit of added functionality.  This drives devs crazy.

I could go on, but you get the idea.  Product guys – rename shit at your own peril.   Devs – protect yourself.  If you use marketing terminology internally in the product then the minute that terminology changes you’re actually going to be worse off than if you’d adopted an abstraction to begin with.  Know going in that terminology will change and abstract stuff right from the get-go.

And if you still end up with an ugly name change, suck it up, do the refactor and march to the new terminology like a good soldier all the way to that Facebook style exit.  And be nice to the product guys.  They make less than you, have to talk to customers and as was pointed out earlier, God does not love them.

Next week: why doing what I said in this post (i.e. abstraction) is a bad idea too.

About JR
Software guy, startup guy, non-fiction glutton, south shore inhabitant

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: