Archive for 2005

A look back at 2005

Saturday, December 31st, 2005

As the end of the year comes closer, it’s time to reminisce. A lot of stuff happened over the last twelve months, both personally and in the glamourous world of software development.

**Personal**

* The most important thing certainly was the 6 week long trip to New Zealand with my girlfriend. What an amazing and beautiful country. They might not know how to make good bread and good cheese, but damnit, if that isn’t one of nature’s wonders, then I don’t know what is. I’ll be back Kiwis!
* We also moved to a new place, which was no big deal, because it’s only about 100m air-line distance from old to new flat. But the place is bigger, better, has just been renovated, and what have you. After 5 years it was time for something new. Also, we lived right on a place called “Boxhagener Platz” which was quite noisy all week long, even on the weekends with a farmer’s market and a flea-market.
* Got my hands on a lot of great tools for the Mac. VoodooPad, MarsEdit, TextMate, OmniGraffle and OmniOutliner (my favourite project management tool), to name a few. This year I actually started buying shareware again. The vibe of the Mac community where people appreciate and pay for great software, finally caught me.
* Went to a lot of great shows, including Silverstein, Alexisonfire, Alkaline Trio, Rise Against, Boysetsfire, and Turbonegro. If you didn’t already know: that’s my way to blow off some steam after a hard day’s work.
* Got to ride my longboard through the whole summer.

**Professional**

* Finished my first big project in my company. A lot of effort went into it, gallons of sweat and tears (and blood?) have been spilled, but it was worth it.
* Made the very unexpected transition from developer to project manager, something I wouldn’t have ever imagined. But that’s the way life is. Unexpected things wait right around the corner. I don’t regret it though. It taught me a lot of things, especially concerning the social aspects of work life. And I’m still learning.
* Got to work with Hibernate which has its joyous and dark sides. The later in the project it was the more the dark side lead the way we used it. Maybe more on that later. While it’s a great tool it certainly has some weird issues and problems with error messages. We also tapped right into the performance issues. 10000 objects in a single session, and you can get a coffee when flushing it.
* Ah Oracle, how I love thee. Hibernate brought the unavoidable relational database with it, and Oracle it was. Has some weird issues (e.g. handling timestamps, not to mention clobs), but it’s still top-notch and incredibly fast.
* Got to love (or hate? or love? or hate?) InstallShield Universal Installer. Spending time with this tool comes close to torturing yourself with a needle, but a really big one.
* Switched from Eclipse to IDEA. Boy what a great IDE.
* Learned so much new stuff that I can’t remember it all.
* Worked a lot of overtime. I’m still not sure if it was really worth it, but I’m leaning towards yes, although it brought me a herniated disk.

**Software development**

* Ruby on Rails rose from the ashes of bureaucratic and overly complicated Java web development
* No sentence could have said, no new web page launched, and no new framework created without mentioning Web 2.0 or AJAX. Time will tell, if both are to stay. If Hani is right, then maybe not. At least not the word Web 2.0.
* Java went lost a lot of heavy weight over the last year nonetheless. Leight-weight is the new EJB. The Spring Framework and Hibernate gained a lot of momentum and made Java enterprise development (one of those words that everyone uses, but no-one has a good explanation for) some kind of fun again.
* A lot of endless, useless and far too emotion-filled discussion about languages, frameworks and tools.
* Much, much more, but I’m sure you all read about it ;)

**Books**

I read a lot last year, and now I can’t wait to get my eyes on something novel-ish.

* J2EE Development without EJB - The sequel to Expert One-on-One J2EE Design and Development. Good stuff, gets boring over the chapters introducing all those mighty and numerous Spring features, but the first chapters are very good and informative, and give quite some insights in how to develop better code, even without Spring. Applying the principles of Inversion of Control to your code already improves it in my experience.
* Cryptonomicon - Read that one on my trip to New Zealand. Good stuff. Weird plot at first, because the setting takes place in different places and times. But gets more and more tensing. While the ending was a little bit disappointing and fast-coming, a great read nonetheless.
* The Penguin History of New Zealand - We brought it with us from NZ, where it’s a best-seller, so it was a good read to complete that great trip.
* Getting Things Done - Well, you’re not a real (Mac-)geek, if you haven’t read it. Getting Things Done was also a huge thing in 2005. Pages like 43 Folders and tools like the Hipster PDA or Kinkless GTD did a lot to help spread the word about it. I’m not religious about GTD, but I’m pretty convinced that it did and will help me a lot as a project manager.
* Hibernate in Action - Well we started working with Hibernate around April, so this one was a must-read.
* Data Crunching - Already wrote a review about it.
* The Art of Project Management - An outstanding book. I picked up some great advice helping me to make the transition from developer to project manager, which is, of course, far from being complete, but I’m working on it ;). I’m definitely gonna read this again next year.
* Ship It! - Wrote a review about it as well
* Agile Web Development with Rails - The Book about The Framework. Great book that is. Fun to read and fun to work with.
* Pragmatic Version Control with Subversion - A slick and easy read about a great improvement over CVS.
* Secure Coding - Dry stuff at first, but makes you think while you’re reading it. The authors provide a lot of practical advice on how to tackle security with your application.
* Beyond Java - This book got a lot of attention over the last few weeks. It has some good points, but I think I’m not the only one when I say that it could have needed a few more eyeballs and maybe some more detail.
* Peopleware - Now those guys are managers everyone wants to work for.
* Refactoring - Was about time to read that. Interesting to see what progress has been made with IDEs and refactoring compared to how it’s done in the book.

Although the real-life work is very important for learning, in my opinion you just can’t read enough. It helps a lot to get different insights and to build an own opinion from it over time.

**Something left for next year?**

Why certainly, me and my team have been working under a lot of pressure for the last 5 months. Now I need to get some more quiet time in my life. And some more time to work out. Coming home after ten to twelve hours of work isn’t really a good motivation to go jogging afterwards, especially if you have a comfortable couch waiting.

My last vacation being that infamous trip to New Zealand some months back, the next stop is Australia. Can’t wait to get back there. Just like New Zealand a huge cultural difference compared to Germany, when it comes to the way of life. With it now being winter in Germany a great place to go. And besides all that, learning, learning, learning.

Technorati Tags:
, ,

On The Perils of JavaSchools

Friday, December 30th, 2005

Now if that’s not a nice treat at the end of 2005. Joel Spolsky has problems separating great from mediocre programmers, because those lazy kids nowadays all learn boring and not-hard-enough Java in school. What a pity. Ten years ago everybody used pointers and they loved it. And now what gives? No pointers, less recursion, no coolness, no being a hard-ass anymore. No-one can crank out a linked-list algorithm during a coffee break anymore.

What happened to the days when students gave up studying computer science, because their brain exploded when they typed in those punch cards over and over again?

Okay, enough with sarcasm.

Is it really a hard programming language that makes for good programmers? As much as I admire C and C++ for what they are and for what they did for the software development world, I’ll also have to say that “hard” languages like them not the basis for great programmers. Sure you need people how know the “bad” (i.e. hard) stuff and how to handle complex algorithms, but you’ll also need people who can think on different levels like user interfaces and, most importantly, communication. In my experience a programmer doesn’t spend the day cranking out fancy algorithms with recursions and whatnot, he works in a social environment. He can be as great as it gets, if he’s not able to be a part of a social group, then he’s of no real value for a company.

Probably most engineers, as Chad Fowler (who has something to say on the topic as well) calls them, aren’t able to create great user interfaces. I’ll include myself here. People and companies like The Omni Group, Brent Simmons, the Jetbrains and Gus Mueller are certainly exceptions here.

As much as I agree that some great software needs complex thinking and the usage of C, and that it’s an advantage to know at least the basics of procedural programming and dealing with pointers, I certainly prefer working in a group with on-their-way-to-being-great programmers who are willing to evolve into something great over time, than work with a bunch of technicians who always dwell in times when linked-lists were something everyone programmed once in while, and prefer writing all code for themselves instead of using code someone else wrote. As long as they’re able to pick the right tool for the job (even if it’s easy Java), then I’m in. Even if they’re mediocre, if they have the right motivation and skills, they can always create something great.

A school won’t be able to weed out great programmers only by their use of a harder language, the work in a team will. Joel, you should know that, considering Project Aardvark. Even if those guys were great geeks, they still had to work together as a team to produce something great. That’s something I (and probably most computer science graduates) didn’t get taught in the university. It’s a skill you’ll have to learn in a real working environment, even if you’re juggling with pointers all day long.

Maybe the real problem here is that, more often than not, you’re not taught 20% of the stuff in college or university that you’ll need 80% of the time. I know I didn’t. If you meant that Joel, you could’ve as well just said it. But well some people just need attention.

Now I’ll get back to that last segmentation fault that dumped me a nice 6 MB core for debugging.

Update: Wow, Joel even made on The Server Side and Javalobby. A lot of other fellas also have something to say about the issue.

A few new releases

Thursday, December 15th, 2005

In case you didn’t notice (which would mean you’re living somewhere in the rain forest), Rails 1.0 has been released. Their website also got a decent overhaul with some 37signals love. Does anyone notice some similarities? ;)
They also have some cool new screencasts about migration support in ActiveRecord, and about how to create an interface for Flickr in about 5 minutes.

Hibernate got bumped up to version 3.1. Spring 2.0 is still pending for this week

And my all-time-favorite tool VoodooPad got a nice upgrade to version 2.5 with some nice new features, like a cool web-export and support for multiple aliases per wiki page.

In other news, I gave IDEA a shot over the last weeks, and I’m hooked ;)
But more about that later.

Handling Unix Timestamps in Oracle and HSQLDB

Thursday, December 1st, 2005

While creating some SQL for reports for our database schema, I ran over some gross issues with Oracle handling Unix timestamps. Some timestamps are saved as milliseconds in the database, but must be usable for date comparisons. What a joy with Oracle. And with HSQLDB. The usual suspects `to_date` and `to_number` won’t work in a simple way. That’s not a new problem as it seems you’ll lose the millisecond fraction. But for reports calculating on daily data that’s something that can be disregarded. The Oracle way is many-fold (what a surprise ;).

I found some solutions here and here. To sum it up, it goes like this:

select TO_DATE(’1970-01-01′, ‘YYYY-MM-DD’) + NUMTODSINTERVAL(/1000,
‘SECOND’) from dual

Looks dirty, doesn’t it? It basically adds a time interval derived from the timestamp to the date 1970-01-01, the one date that Unix geeks love like nothing else (well, except sed & awk maybe ;). Notice the division by 1000 to convert the seconds to milliseconds, that’s the point where you’ll lose some precision. The other way around is quite similar. Here’s how to fetch the timestamp from an Oracle date type:

select (SYSDATE - TO_DATE(’19700101′, ‘YYYYMMDD’)) * 86400000 from dual

Now we’re subtracting the date 1970-01-01 from the current date and multiply it by the number of milliseconds that a long day at the office might have.

If that’s not awkward, then I don’t know what is.

But wait, it gets better. Now for HSQLDB. You think you’ve seen it all, but here it goes:

select “org.hsqldb.HsqlDateTime.getTimestamp”() from my_table

Yep, that’s the stuff. Thank god you can use static Java methods in HSQLDB, and thank god they’ve implemented some of the stuff in their own library methods. It might not be the most portable SQL, but it does work. If you want to get the current time as a timestamp, then you’ll simply use:

select “java.lang.System.currentTimeMillis”() from my_table

I have not yet found a way to convert a specific date (e.g. from a column) to a Unix timestamp with the simple tools (i.e. public and static methods available). An alternative would be something like a “stored” procedure, if it can be called that way in HSQLDB:

public class DateConverter {
public static long toUnixTimestamp(String s) {
java.sql.Date date = java.sql.Date.valueOf(s);
return date.getTime();
}
}

Since HSQLDB treats all date and time columns as strings within SQL, you’ll have to go with a string parameter. This methods will only work on date typed columns, for timestamps (the SQL ones) you’ll have to use `java.sql.Timestamp` instead. The rest is the same. Now you’ll have to put the class file into the classpath available to HSQLDB and you’re good to go. When used in SQL it will look like this:

select “DateConverter.toUnixTimestamp”(curdate()) from my_table

What a joy.

Technorati Tags: | | | | | |

Is it Friday yet?

Thursday, November 24th, 2005

Apparently it must be, since the Pragmatic Programmers have just released the next bead of joy, called “Google Maps API”, from their Pragmatic Fridays series (mentioned a while ago on this site). I never looked at the Google Maps API before, but it looks quite interesting. Now if only it were Thanksgiving here so that I’d have time to play with it ;).

(Via PragDave)

Technorati Tags: | |

Project lists for the D*I*Y Planner

Sunday, November 20th, 2005

I’ve been using my own adaptation of die Hipster PDA for quite some time now, and I gotta say, it’s convenient enough to not get in my way, but serves me well as a list of things I gotta do. It’s also small enough to take it everywhere with me. I’ve had my ups and downs with Gettings Things Done. At first I started using an electronic version with VoodooPad, inspired by Mister Charlie, to keep my lists. That’s why I bought it in the first place. Synchronisation to my iPod is a nice feature, but it’s only one-way. You can access your lists, but they’re not living. Adding new actions or projects requires a computer which is good enough for some people, but I tend to prefer paper for this. Having to use my iBook for synchronising my lists is not really convenient, and I tend to lose focus.

So I tried the D\*I\*Y Planner templates with a brace-style approach, like the original Hipster PDA. But handling the sheets of paper was a hassle, so I looked for something more convenient. Then Jeff Torgerson posted his adaptation of the Hipster PDA to the 43 Folders Google Group. Since I like Moleskines too, it seemed like a worthwhile approach. I tried it with a Moleskine Reporter Notebook, and it feeled like a perfect fit. My adaptation looks like this. The templates are taped to the pages in the back of the notebook, the front is for notes, and the tabs are for (you can guess it) easier navigation.

One thing was missing though. The D\*I\*Y Planner templates come along in different types. Next action lists, project templates, waiting lists, you name it. You might wanna check them out, by the way. The project templates are a good start. There’s one template for every project. But since I tend to have several different projects that don’t need such a large template, I came up with a slightly modified version of the action lists, a project list. A simple one-line project list and one with two lines per project. Feel free to use them.

Technorati Tags: | | |

Creating XML with PHP and Rails

Friday, November 18th, 2005

Over at the Big Nerd Ranch they’re showing how to create XML with PHP DOM. You might wanna have a look at it and compare that to the simple Rails approach:

— teams.rxml —

xml.instruct! :xml, :version => “1.0″, :encoding => “UTF-8″
xml.teams do
xml.team do
xml.name “Atlanta Braves”
xml.stadium “Turner Field”
xml.league “National”
end
xml.team do
xml.name “Chicago Cubs”
xml.stadium “Wrigley Field”
xml.league “National”
end
xml.team do
xml.name “Baltimore Orioles”
xml.stadium “Camden Yards”
xml.league “American”
end
end
— end —

When speaking of PHP5, they could at least have pointed their readers to the SimpleXML library. It’s not as pretty as the Rails solution, but it’s a start.

Dilbert the Wise

Friday, November 18th, 2005

Though I’m usually not a big fan of Dilbert, this comic strip hit the nail on the head: Agile programming doesn’t just mean doing more work with fewer people.

Via pragmatically.net.

Technorati Tags: | |

Learn Your Lessons!

Monday, November 14th, 2005

Learning is an important part of life. Even after school/college/university, it never stops. In 2 years of my life as a professional I learned more than in 5 years of university. That shouldn’t come as a big surprise for most people having a job, but it came as one for me. But there’s a difference. When you’re studying at college or the uni, professors tend to tell you what they know (if what they tell you is actually worth a penny is a different story). In professional life, it’s up to you to learn. If you don’t learn, you won’t improve your skills, and therefore, your net-worth won’t increase, and you’ll be stuck, stuck at a certain job, in a certain position, without much changing for you. If you stop learning at all, you won’t be a good investment for your company anymore. That might sound harsh, but that’s the way it is. Some people manage to stay around like that for a long time. The bigger the company, the bigger the chance that you’re gonna meet someone like them. So learning is an investment. It’s an investment in yourself. The time you can put into learning will pay off in the future, not necessarily with a bigger salary, but with more confidality, professionalism, raised productivity, you get the idea.

So what should you learn? That’s the most important question of them all. It’s not easy to conclude what might be important for you in the future. You can’t and you won’t know everything, and you won’t need to. You can learn a new programming language, play with that tool you always liked, or just look at your own weaknesses. There is enough to learn. I tend to focus on my personal weaknesses, and on stuff that I witnessed in my projects. The last part is very important. A lot of projects go along, fail, never come to an end, or succeed with anybody ever questioning why. That’s too bad, because a lot can go wrong, or can be done wrongly during a project. A solution to a problem turned out to be a big problem by itself, someone made a bad decision, your manager did something your whole team never really liked, or a new tool turned out to be a huge waste of money without having any positive impact on the project (think UML, not your everyday text editor). The list is endless. I recently started reminiscing on the last two years of my life, professionally of course. The personal stuff too, but that’s a different story. I brainstormed the project I was involved with, the tools we used, the kinds of communication, how the team worked together, what I did wrong, what someone else did wrong, the way the project was lead, the technologies used, and their impact on productivity. Once I started, my paper sheet soon didn’t offer enough space for the ideas that popped into my head. Brainstorming is a cool tool for recollecting thoughts, since your brain follows the associations you draw and soon new stuff comes up that was somehow related to what you just jotted down.

After I got the feeling that I captured most of it, I started putting them together as notes and to explicitely shape the lessons I learned from the specific experience. It’s important to not only point out the lesson learned, but to name the reasons that lead you to your conclusions. Writing “EJB is unproductive” is the one thing. Figuring out why is the other, and definitely the more difficult task. It has to be more like: “EJB is unproductive, because of the longish deployment cycles, because of the huge overhead of the container, and because it enforces programming boundaries that restrict me in the way I normally develop software”. I tend to go up the levels of abstraction from specific technologies to more generic conclusions like: “Pick your technologies wisely. Choosing the wrong technologies for whatever reasons (because it’s cool, state-of-the-art, expensive, everybody else uses it) can have devastating consequences on the project.” Now that might be obvious, but it’s just to give you an idea.

That brings me to the next important thing with learning: Critically analyze what you read an hear. This might sound familiar to those who read “The Pragmatic Programmer”. But the idea is exactly what you need to do. Look at things objectively and in terms of you and your project. Choosing a tool, because it’s cool, is the wrong way to look for a solution to a problem. The tool has to fulfill a need you have, it must be the solution to a problem. But that sentence is true for a lot more. If you look critically at things you witnessed, mistakes you made yourself, you’ll learn a lot more than just ignoring it with the all too common attitude, that it surely won’t happen again in the future. I met people from both sides of the story. Some tend to ignore mistakes or problems, although they do them again over and over. They don’t critically reflect on themself, they don’t reflect on the project, and the people they’re involved with. Either they’re too lazy, ignorant, not aware of the problem, or it’s simply too painful to analyse a problem. The latter is a common syndrome, especially with a manager that caused a project to fail, but doesn’t want to come out as the root cause for the failure. Mistakes and problems will be silently ignored and, to nobody’s surprise, will be made again. That’s why it’s important to not only learn from your own mistakes or successes, but from the people around you as well.
I’ve seen all of these different types in action, and it wasn’t a pleasure to look at. But I learned one thing from that experience, and that’s exactly what I’m writing about: Learn your lessons!

Books are another important source for learning. The best books that I’ve read and that have taught me the most were books that told me how and why something works. This includes books like “Ship It!” and “The Art of Project Management”, and of course “The Pragmatic Programmer” that draw on actual experiences and on stuff that did or did not work in people’s professional lives. Since I noticed that a lot off what I read gets lost somewhere in the neural depth of brain I started taking notes about specific lessons learned from books as well. I tend to keep them short, since I can always get back to the corresponding book to go more into detail.

How should you do it? That’s up to you. I have a Moleskine at hand everywhere I go, and when on my computer, I fire up my trusty VoodooPad to collect the next lesson. Having something to write at hand is important, because your personal conclusion to a problem might come at the most unexpected moments. I collect the lessons electronically, because I only want to learn them once.

It doesn’t matter how you do it, it’s only important that you do it. Learn! Improve your skills, your knowledge, and your net-weight. It will definitely pay off in the long run (I was going to write “in the end”, but maybe it won’t pay off anymore then ;).

Technorati Tags: | | |

On Working Overtime

Thursday, November 3rd, 2005

With the end of last week I worked for the 19 days straight for about 10-11 hours a day including weekends. Nothing special in our industry. Everyone did it or still does it. I love my job, but the fact that I didn’t really get to see my home, my girlfriend and my friends during that time, got me thinking about what value working overtime actually delivers.

Don’t get me wrong, I’m not saying that working overtime is bad. If I’m really into a task, then I like to finish it before I get home. If the solution is within reach, then screw those 2 hours that I stay longer. At least that nasty bug/cute feature/cool algorithm is finally done. If a customer is waiting for an important patch, because your software somehow (these bugs come along in mysterious ways ;) screwed up his daily business, there’s not much of a choice. But, as always, the coin has head and tail.

During the time I thought about this some main points came up: exhaustion, productivity vs. steadily decreasing concentration, frustration and the death march factor.

* Exhaustion

This might be the first sign you run over. Not getting a lot of rest or working too many hours a day for a longer time will definitely lead to exhaustion. Exhaustion certainly isn’t a good feeling. Sure, you can crank up your caffeine intake, but will it have any effect in the long run? Caffeine only has temporary effects. It can stir up your concentration for a few hours (or less, depending on just how exhausted you are), then you’ll go back to that espresso machine to get more of that precious juice that brings the life back into you. Some people I know drink coffee like water. I’ve had that experience to some level, and I hated it. I usually have 2 to 3 latte a day, but I easily added another 2 during the last days. And I definitely hate keeping my concentration up with caffeine. Some nights of good night sleep will most likely have a better effect on your overall concentration than the temporary push of a coffee (as good as it might taste ;).

In the end exhaustion directly affects your work. If you’re tired, you won’t have enough concentration to solve the simplest issues. Not doing anything about it won’t make it better. If you’re exhausted, go home early, take a nice hot and steamy bath, and go to bed early. Simple, yet refreshing.

* Productivity vs. lost concentration

What does working overtime really bring? Does doing it provide any additional value for the employer? To the outside it might look as if the employee is willing to work more to complete her tasks, but isn’t the loss of concentration causing loss of efficiency, because the employee is actually making more mistakes? It’s definitely questionable in the long run. Working week after week, weekend after weekend certainly doesn’t bring value for anyone. Employees are getting more and more tired and make more and more mistakes, so that the software will either be buggier in the end. This will either lead to a longer testing phase or to unsatisfied customers. Is this really what an employer could want? Hardly believable.

This issue is sometimes easily overlooked by management (or so one could believe). It’s easy to tell your employees they have to give 120% for the next n weeks (n being an infinitive number usually greater than 1). But the repercussions can be huge. But it’s two-fold. The best solution isn’t to work overtime at all, either. A developer should understand the pressure her manager has. A manager has some quite different problems than she has. He has to report to his manager, or, in smaller companies, directly to the stakeholders. They’re interest is to get the project out the door as soon as possible to satisfy their customers and create good revenue to satisfy their bosses, the shareholders. So there’s the chain of responsibility that definitely has to be taken into account. A developer should at least know the pressure his boss has. This puts some things definitely into perspective. But that’s a different issue. It’s just important to not just dismiss working overtime. Both parties have to find a solution that satisfies all involved parties, each one holding one to their standpoint will only lead to frustration and a bad team atmosphere. A good manager knows this and knows what he can demand from his team. A good team, on the other hand, knows what it can deliver under which circumstances. But if a project is late, then it should be honestly and openly talked about the potential solutions. If working overtime won’t help, then other (more or less drastic) measures must be taken into account.

* Frustration

Working overtime endlessly doesn’t only exhaust, it stirs up frustration, especially if you spend time with code/framework/tools that tend to cause trouble (I’m thinking of InstallShield here, because it caused me a lot of trouble in the last weeks, but you name it, Hibernate and JBoss are good examples here, too).

The thing with frustration is that it works like a spiral. There’s a new problem, and the frustration rises. More frustration causes more mistakes and therefore, more problems. This is especially true, if you’re the only one working late in the evening or during weekends. That causes even more frustration.

Frustration brings another problem. It blinds the view from the real problem (be it the conclusion that either the problem lies somewhere else, or the fact that the frustration reached a level too high to work effectively). There’s a problem to which the solution might be so simple that it’s actually very easy to overlook it. It happened to me much too often during the last 2 weeks. There’s the productivity/error ratio again. A small error might just cause you several hours of cursing and swearing and trying the most complex solutions to a problem that, in the end, will turn out to be a simple one. In the end, it’s very questionable, if working overtime for several weeks really is for anyone’s benefit. It should be in the employer’s best interest to have an eye on her employees’ working time. It’s honorable, if someone works 10 to 12 hours a day without complaining, but that might either cause trouble for the employer in the form of bugs caused by low concentration, or it could as well mean that she who works long days, has problems structuring her work. Both problems can be solved, but it might be that she can’t handle them by herself.

Rising frustration causes easy blame of problems to someone/something else. If you’re frustrated, it’s easy to say that it’s only Joe’s fault, because you have to sit here and fix his code, and he’s off for the weekend with his wife and the kids. It’s quite easy, because Joe isn’t here, so he can bear your blame without a problem. Being frustrated tends to cause looking for the easy view on specific situations. There’s problem A that causes feeling A (frustration), but since you’re alone in the company there’s actually feeling B which might be anger. You’re mad at your colleagues for not being here with you, however unreasonable it might be, because maybe they can’t help you at all. I’ve gotten more aware of this over the last months during the normal work week, but during those long hours during the weekend it’s easy to forget that feeling A is the actual reason you’re upset. This is called the Satir model, where a feeling B hides another feeling A, although feeling A is the actual cause for your current mood. Dealing with feeling A might be a lot easier than with feeling B. Saying to your colleagues that you’re mad at them, because you felt that they let you down, might have bigger repercussions than just screaming at the sky to get that frustration out in the open without hurting anyone.

The last issue that comes to mind with regard to frustration are doubts. Reasonable and unreasonable doubts. The more frustrated you are the more you doubt everything, everyone and everything else. Including yourself. You doubt that you can finish your task on time. You doubt that the rest of the company really cares that you’re working your ass off. You doubt that the tool you chose really was the best one for the job. You even doubt that this job is the right thing for you. I believe in nothing really, but I learned that it’s important to believe in yourself. Having doubts in yourself is the worst that could possibly happen. If you start to doubt your own skills, then you can pretty much pack and go home, because if you don’t get your act together pretty soon, the task at hand won’t be done on time, that’s for sure. Having doubts is quite natural, but if you doubt that a task can’t be done on time for reasons A and B, then you better talk to your manager about it. If your doubts seem unreasonable, do everything to get them out of your head. Go for a walk, get some fresh air, do whatever it takes.

* The [death march](http://www.amazon.com/exec/obidos/ASIN/013143635X/javaddicts-20) factor.

A famous influence on working overtime. Very common during the dot-com days (it is still today, but it was far more common back then). It’s not a direct consequence concerning working overtime, but it definitely has a huge influence on the effects of doing so. Everyone had a common goal and was working their asses off to reach that goal. The reasons might be different, be it a simply unachievable deadline that everyone wants to reach for whatever cost, a boss that just wants everyone to work all day/night/weekend to reach a goal that everyone thinks it is from another world, or a team that just wants to create something very cool together, and everyone has the highest possible motivation to get it done. The different kinds of death marches have different outcomes with regard to productivity and motivation. If there’s a goal that everyone agreed on, and everyone gave her commitment to reach that goal, then it’s a totally different situation than the one with Mr. Bossman who just wants everyone to work all day and night so that if the team doesn’t reach his illusionary goals he can easily blame it on them. The former team certainly has a different motivation than the latter. Reaching a goal together with everybody wanting to do it will benefit everyone in the team, because everyone motivates each other. Everyone reminds everyone of their goal every day. Mr. Bossman just reminds everyone that the deadline must be reached, or else. The exhaustion factor might exist in both teams, but the frustration factor wiil certainly have a bigger influence on Mr. Bossman’s team. Which team would you rather be on?

So what’s the solution? Hard to say, I didn’t came up with any, yet (if you did, let me know). Avoiding working overtime isn’t always an option, but it’s important to keep an eye on your own physical und psychological shape, and to draw the right conclusions at the right time. So I’m not saying you shouldn’t do it, but you should think about why you’re doing it and for how long you’re able to keep doing it. Sure, this is something one has to learn, but what isn’t? After all, it’s at least always appropriate to ask the simple question: Is it really worth it?