Programmer,coder or debuger ?

  • Thread starter Thread starter Jenea Ciur
  • Start date Start date
J

Jenea Ciur

Hi !

I am student in 4th year, Computer Science,and already have been
working for 1.5 year.
I really like programming, I this is what I do a lot.
Before getting a job, I wrote lots of programs by myself,enjoying it
and thinking that I can deal with this kind of job easily.
But when I started to work a a company,I was putted to debug already
written very huge programs...
This is why I jump from one company to other,now it is 4th company,
where the salary is really nice,conditions of work are exceptionaly,
but when it comes to debug ( this is what I do in very now moment )
very ugly code of others... it drives my crazy!!!
It's very difficult for me... It is so easy to write you own code, and
so difficult to analyze others especially if it is millions lines
program and I am only a begginner in this stuff.
All I need are advices from other guru programes, about there
experience in diferent jobs... was that difficult first time to debug
others code ? What do they do in different jobs ? why do they leave
that jobs ?? How many company do they jumped... etc
Thanks in advance from all your advices.
 
90% of the work I've done in the past four years has been to debug
other peoples code. Systems have been around long enough that companies
are often not looking to reinvent the wheel, but to fix what is broken.
Most companies I've worked with think that the problems (and solutions)
are minor compared to designing and rewriting - so they often fail to
consider that as the best long-term solution. I've been doing this kind
of work for 15 years now - and I've found that the average (and even
above-average) devs aren't really that good at problem solving,
therefore, they're not very good at debugging. So, those that aren't
good at debugging end up writing code, and somebody else ends up
debugging it.

The flip side is - there's often more $ to be made in fixing problems;
also, you can be as honest as you want about the state of the code
before you fix it - 'cause you didn't write it - whereas most people
who write code will tend to try to hide their mistakes and fix them
silently before owning up to them in front of management.

-Chris
 
Hey, let's have children - combining our genes will make up the ultimate
program guru because digging for well-hidden bugs is what I'm really best
at!
Which is not so bad at all, because at least in 4 of 5 tasks, I had to
cope with existing code - test, fix bugs, migrate to other platforms -
more seldom add functionality... Starting by 0 and build up a project is
a REALLY rare job and mostly done by seniors.

I presume that part of your problem in debugging is that you do have in
mind how YOU would make said functionality - so you're unnerved by trying
to bend your brain around other peoples paths of thinking (apart from the
occasional freak whose ultimate goal must have been to squeeze an entíre
programm into one line of spaghetti code).

If that is the case, you might find it helpful to put yourself in place
of the machine.
Coding - you have to keep the outward structure in mind and then go down
to objects, classes, functions,... - but digging for bugs is easier done
bottom up: You have what you have, and you follow the trail of individual
information bits, messages, electrons, if you must, to see where you run
into the ditch and then you fix that particular pothole.

Improving other people's code, in my opinion formed of 13 years of
professional software engineering in ... wait... 6 different companies
for longer than half a year and I-don't-know-how-many project jobs, can
only be done in 2 ways:
Fix pothole by pothole and pray no one will ever read again the resulting
patchwork - or throw the whole thing in the bin and do it anew. The
latter takes more time most of the time - and time is money - so you'll
rarely get the occasion to do it (only in extreme cases I could ever
convince my superiours that doing it anew is better than trying to fix
that crap). And be sure, IF you do it, you're likely to leave enough bugs
for the next guy to curse you ;-)

Good luck,

Kerstin
 
Jenea, I understand how you feel. I've been programming for about 8
years now, at 5 different jobs, and I've seen my share of UGLY code.
Of course, beauty is in the eye of the beholder. But for those of us
who actually take pride in a well-written and elegant piece of code,
it's hard to swallow some of the mistakes that other programmers make.
But I've found that if I have to debug a function that runs for 15
pages or so, I know that even if I do fix a bug that time, I'll be back
to debug that same function in the future. So whenever I have to sift
through pages and pages of code like that, I refactor it the first
time. You may still be left with ugly code, but it will be smaller
ugly code. And I've found that my coworkers and employers alike
appreciate this, as it seems everyone else is either afraid to do it,
or doesn't know how.
 
Back
Top