jueves, 4 de octubre de 2007

Closures means everyone must go back to college

"Usability" means the customer is always right, that you don't tell the user what the application is about the first time they use it and yet they are able to figure it all out because the user interface is somehow familiar to them.

If we applied this criteria to computer languages, no one would be programming in other languages that were not Visual Basic, because circa 1996 it was the mainstream language and all the rest was considered niche.

Where are now all those Visual Basic applications?

They are considered crap.

Unmantainable crap. That is what Visual Basic is.

I see no one asking for Visual Basic to make a come back, not even hard core VBers.

Closures

With closures it is the same thing. Now that Java is going to get closures, developers will need to understand that concept, because all languages will come "closure ready".

Java for example makes it impossible to code in Java if you don't understand object orientation. Of course you program a website and you can do a lot of things using IDEs, but if you don't understand object orientation, eventually you are going to face a wall and bang your head for months. I've seen projects fail because of this.

The same with AOP, interception and dynamic proxies. Now with the help of Spring, everyone is exposed to interception. If you don't get interception, you should be looking for the janitor job or the manager job, but eventually you are not going to be able to debug and fix those bugs.

Now closures come to the rescue. The first thing you are going to learn about closures one night in the middle of a debug session is that closures do not see the updates on global variables.

Remember how professors at the University talked endlessly about the bad style of using global variables? Well, now you willl see for yourself that you need to redesign massive amounts of code just because you were using global variables.

And as always, massive amounts of programmers will go the easy route and turn into managers. After all it only requires you to think you are incompetent (which now you will be convinced anyway) and therefore you will think you will need to brown nose upper managers. Some people like the attention and will simply promote you, as long as you keep your act together, that is, you keep brown noising, because after all, politics in an organization is not about who is able to do what, but who is best at the polls.

Most companies, when they have grown enough, can't fill all the positions with geniuses. They need to hire less than average people. And this means geniuses become very bored to work with you. I mean they can replace you using a simple script, so they wonder why you were hired in the first place.

If the geniuses can't replace people as fast as the manager can hire these less than average people, geniuses tend to leave. Which means you get all sorts of internal jokes like "how many developers do you need to change a bulb" and stuff like that. If you hear those jokes, you know management is considering to reduce the headcount, maybe not today, maybe not this month, but certainly this year.

And after the crunch, new and fresh developers come to help. Those that still believe in life and work and who of course have never worked and think that if they perform ok they will be promoted, etc. They now know object orientation, they understand Spring because they used it so many times in their homeworks and they used closures a lot. So they perform 10 times faster than older developers and they almost have no bugs, for 1/8 of the wage.

Would you stay as a developer or look for a promotion?

It doesn't matter how much you know, there will always be smarter kids just arriving from the local university and ready to fix everything.

So you have 2 routes:

1. Go back to college to learn closures and then get the same pay as a rookie.
2. Get a management job, get better pay and forget about the whole thing.

Getting into management is kind of easy. Besides the cosideration that you are worthless and therefore you need to brown nose your bosses, you also need to make those happy developers work, because they are the most valuable resource and they need not to know it, or otherwise they would leave for a better paid job.

Usually managers lie. And they lie so that they make it look like you lie. Let us take a closer look at this, because you probably think this can't be possible.

Managers, by definition, have to have an office with a door. Also they need to meet people individually.

Have you ever talked to a manager? They always tell you there are so many projects, but how come we are not working in those projects?

The real reason managers talk one on one, is that the story they tell one person is not the same story they tell another one. And they know projects last for a short period of time (a few months to a few years), so most people will be fired, and the manager knows developers will get nervous, so they need to say with a straight face a lie ("this person was reluctant to do his job", "... to put more effort", "he was inadequate", "he couldn't work with the rest of the developers", "the client didn't like him", etc.), so that other developers will not run en masse.

And managers will of course lie about the fact that they lied. That's the wonderful thing about lying. The not so wonderful thing is that from time to time people confront you, they discover that you lied and they tell everyone. Those cases are pretty unconfortable for managers, but it is like what developers do with bugs: they debug. When managers are confronted with a developers who call them liers, they promptly fire those developers on the basis that the individual developer is lying when saying the manager lied, and not respecting authority.

Upper management is usually on the side of the manager, unless the manager doesn't know how to pull the ropes.

What do I mean now?

Upper management will not fire a good manager because of a lousy developer. And a good manager is the one that can get his act together in front of several other managers and even with the client (which is usually a company full of managers). So managers tend block and surround good developers with his own people (that is people who is loyal to him), and let people communicate with people in other companies as long as they stay loyal.

And for them to be loyal, they need to understand their real value: worthless. If they are worthless, it means they are ready to lie, because they can't go through life showing their real self. They have to pretend.

This is exactly the same that happens in college when people copy in an exam. Why do they do it? Because they know that they can't perform. Are they doing a disservice by graduating without knowing? Yes, but they do no harm in the market because they know they don't know, therefore they don't perform, but ask people who can really perform to do the job, while they try to sell the services to other managers.

This is really important. People who have companies can't really perform at the job. Most managers in high tech companies can't code, except maybe Bill Gates.

So they need to lie to their employees, letting them think their job is irrelevant. You job can be irrelevant only if the managers can control what you are doing. And developers know this. Therefore developers tend to hide what they are doing (they don't write unit tests or funcitonal tests for example) so that it lloks like they really know what they are doing, while the truth is that they have no idea.

While managers tend to control what developers are doing by testing things, not directly, but with the help of testers. Isn't life great? You design a system and let it run, then get paid monthly for running it, which is not more difficult than pressing a few buttons, but on people's minds.

No hay comentarios: