You have a new message.

He opens the app and clicks on the newly arrived email. It's from the head of the marketing department.

"Hello Steve,

Hope you're fine. I am contacting you to let you know that we decided to use a third-party solution for the automatic ad delivery system, as we think that refining and maintaining our own might not be worth the cost, before we actually figure out if this a viable idea. As you can imagine, today's meeting serves no purpose now and therefore it's cancelled. Thanks a lot for your effort.

Best regards,
Jamie."

Steve is utterly frustrated. He spent more than 80 hours on this module and, although it was far from complete, in his eyes it was a marvel. He feels unappreciated and depressed, now believing that any effort to produce the best possible solution is pointless.

The swift pace of events in our story may seem unreal (as well as Steve's reaction), but let's be honest. The time when your work will be thrown away will come, sooner rather than later.

Everything is changing - and fast.

In fact, the only constant, when it comes to software, is that nothing remains the same for too long; a fact that annoys and sometimes angers developers, especially if it means that they have to abandon their latest creation. Even though we won’t always admit it, we tend to overreact whenever we feel our work and effort are so bluntly rejected, and yet we are cursed to experience this throughout our career:

• As juniors, our solution may get dismissed because, although it works, it lacks certain qualities.
• As middles, we try to design comprehensive systems with a million capabilities, which we are then asked to simplify, because users will find them confusing.
• In our senior years, we start making decisions that form the foundations upon which entire teams will build and develop, only to find out that another decision that precedes us has completely changed the course of action.

These are all valid reasons to be upset. But each and every one of them is still a valid reason for our work to be turned down. It's not that they don't like us or that we are insufficient. The truth is that for any problem or need, there will be a solution that is more suitable than what we have proposed, at any given point in time.

Needs change; and so do the means to meet them.

• The number of users that visit our website may have doubled, meaning that a part of it must now be rewritten to accommodate all that new traffic.
• We now have to communicate the outcome of a workflow to an external party and we need to change how our logging behaves and reports events.
• The system is abandoned because stakeholders changed their way of doing business and they now need a new system that is completely different from the existing one.

Stop getting emotionally attached to your piece of work. It's almost certain that most of it will end up in the garbage because... that's how this world works. Ideas get rejected all the time and, with them, all the artefacts that were produced to achieve and materialise them - including your code. And that's actually fine. This means there's still work to do, challenges to beat, skills to improve. You are still needed and your destiny awaits you!!!

So we should stop caring and just do as little as possible?

Of course not! Even if I was telling you so, there's no chance for a developer that loves his/her job, to stop caring about his/her creations. You'll always do more than you're asked, maybe invest more than you should, and it's certain that you'll want to make that extra leap of faith. Keep in mind, though, that this a decision you're making for yourself. It's you the one who desires the robust and modular solutions more than anyone else. It's you who wants to try a different way this time. It's you that stares in awe at your new approach of dealing with that problem. These are usually your expectations, your highs, and that way of thinking is the exact reason why you're destined for this job. Because developers have to anticipate things others don't and plan ahead before it's too late. Even if we daydream unblinking in front of a monitor, we always come back to reality and face challenges that, sadly, only another developer would understand.

So my suggestion is not to change your expectations, but to tweak them instead, in order to protect your future self from feeling how Steve felt in our story. Think about what you're trying to achieve and for whom you're designing this. Focus on today's outcome instead of tomorrow's possibilities, when you're evaluating your work. Tomorrow, your code may be worthless (I promise you it will be😛 ) but, for now, it provides great value and you can express this in many ways:

• It’s up and running (having issues or not) and you should be content, even if this only lasts for a couple of days. It might be just useful for some or invaluable for others. Filling a gap for a user or bridging two different worlds in a company. Nevertheless, it serves its purpose. Be proud!
• It may never see the light of day, but it has surely left a mark. It made you better. You tried new things, failed a bit and/or learnt a couple of new topics. Even if nothing of the above was the case, it totally helped you in some way to take a step towards mastering your craft. Accumulating knowledge and experience is your only weapon anyway.
• You get paid for doing what you chose (and hopefully love) to do. Plain and simple. Bear in mind that, for some, this is still a wild dream.

Keep thinking like that, and you'll never let yourself feel moody when your work will be tossed away, because now you know: It either served someone's need or yourself. The effort is never futile.

ATCOM: From Digital to Purpose