The Rush Age

We live in the rush age. We are literally overwhelmed by the amount of things we have to do, both at work and outside it. We leave work and have a bunch of emails, Facebook notifications, tweets, text messages (among others), waiting for response. Even worse, we are in bed keeping an eye open looking at our mobile phone in case we get a new notification. This is ridiculous.

As software developers, the same thing happens at work. The feeling is that we need to be more and more productive. We have access to a huge amount of information and tools in order to achieve this (Google, Stack Overflow, that new library that claims to simplify your life 1% better than the one your are currently using, etc.). But the feeling I get is that all of this is turning us into consuming machines. We consume information, process it and pack it again as soon as possible. Our output? Mostly code. And how does this work? Let's see an example:

So we are coding, and we get stuck. Here is a common algorithm:

1. Look at the time tracking tool and see the task should already be finished; we are late. We feel the icy breath of time down our neck.
2. Breathe.
3. Go straight away to Google and type (or copy & paste) the error or question.
4. Stack Overflow comes to the rescue. Our adrenaline gets out of control before clicking on the first link.
5. Skip the question without even reading it and scroll down to the answers. There is that glorious green tick for the accepted one. Problem solved!
6. Breathe again.
7. Copy the solution and paste it in your code. Quickly. Seconds matter!
8. If the solution doesn’t work out of the box, tweak it or repeat from 2.

Has anyone experienced this? I did, and I find it terrifying. We are in such a rush that can even fall into the trap of stopping to think and blindly apply pre-baked solutions.

The same thing applies for libraries and frameworks. I like libraries that simplify your life and save you time, automating repetitive work, don't they? Actually... do they? Why don't we create our own tools that go straight to our problem, usually using much less code, and, more importantly, make us think about how we are solving the problem? I'm not suggesting to write from scratch all code that some people have already created for others to be used. But isn’t creating our own solutions a way to keep us in good shape instead of being some sort of libraries-assemblers? And, by the way, has anyone used a library that, at some point, didn't fit the needs and tried to extend it or ask for support? Sometimes this is not straightforward.

The same thing applies for our operating system. I've used Mac OSX, Windows and Linux (specially this one). Lately, I've been using Mac both at work and at home. It makes you more productive, no doubt about that (I think they balance stability, user interface and access to low level - alias 'console'). But that simplicity makes you lazier in the long term and therefore you lose the ability to think and solve problems. Try to go back to a Linux distribution that needs some configuration, after spending 3-4 years on Mac/Windows. You think that you don’t need this? Then you have to set up a custom server for production at work. You will be surprised by how tough it is, not because Linux is that tough (ok, this is arguable), but because it requires you to understand what you are doing. Does this example look similar to over-using Google and libraries or frameworks without understanding what they do, or to having troubles with writing our own solution in case we need to? It does to me, and it leads to the same problems.

I'm not saying that we should go back to the cave age, build a spear and get some furs. Using Google, libraries/frameworks and a user-friendly operating system is ok. I'm just concerned that the amount of pressure (sometimes self-imposed) to be productive is making us unable to think by ourselves. I've found myself and people around me giving in and taking the easy/lazy path quite a lot of times. We should be careful and try to balance our productivity and the ability to struggle with problems, because what we learn in the latter one also makes us more productive in the mid/long run.