Slashdot Mirror
How to be a Programmer
Martin L. Smith writes "Rob Read has posted his magnum opus, "How to be a Programmer: A Short, Comprehensive and Personal Summary" to Samizdat Press where it can be scarfed by the masses. Rob's book is a forty-page tour through the million-and-one things he thinks a programmer ought to know as he sets out into deep water. One of the reasons he posted this was to get some feedback, so tell him what you think. Samizdat Press is maintained by the Colorado School of Mines to provide a distribution point for free (mostly earth-sciences related) texts."
I think that 90% of the people here already have the whole "how to thrive in a seclusive career path that is extremely difficult to find employment in and you end up having very little contact with the softer gender" thing down pat, thank you very much.
1) Write a spec ...
2) Send spec to Indian/Russian/Chinese Programming Outsourcer
3)
4) Profit!
ok, i just skimmed a couple lines of this thing but it seems to that he glosses over some major areas: "Idealists may think that design...is more fundamental [than debugging] but they are not working programmers." IMHO it's nearly impossible to implement a major system without doing some serious design work first - debugging can fix logic errors, but not design flaws.
That one can't learn from reading Dilbert and watching Office Space.
"Why didn't you put a cover sheet on the TPS report!" - "Terrible" Terry Tate.
---anactofgod---
"Equal opportunity swindling - *that* is the true test of a sustainable democracy."
...Simple, just keep doing the stuff they give you. When one tool doesn't work, pickup and learn a better tool. I remember taking on a student job as a programmer, back in 1981. The path has twisted and turned a bit, but I'm still doing it until I find something else I really like ... or win the lottery ;-)
A feeling of having made the same mistake before: Deja Foobar
How to deploy the software and updates to it.
It gets quite complex in custom business applications where you have to distribute client, middle tier and database updates to production systems.
Anyhow, my 2 cents.
Here's what is important to me as a programmer:
1. Always keep learning - it's not as important how much you know - it is important how fast you can learn new things
2. Don't just implement something for the sake of doing it, or because it will look cool on your resume. Make sure you have valid reasons for what you do, preferrably backed up by some research. Change isn't bad unless it is change for the sake of change.
You find this humorous, centurion?
This looks like it should be titled "How to be a Developer", as much of it is oriented towards programming for a project or coporation...
The 'Thrown Out Like an Old Sock' chapter.
It's Christmas everyday with BitTorrent.
1) Write code
2) Avoid commenting your code at *all* costs
3) Obfuscate code, heavily and often.
4) Make sure everyone sees your code. This will culture a sense of fear and awe in your coworkers. Particularly if you can make your Perl code look like assembler.
With these 4 easy steps, you too can be one of the last people to be laid by your employer!
Karma: 0 (But I wield a mean +10 Vorpal Apathy)
just read this handy guide to writing unmaintainable code and do exactly what it suggests
There is no substitute for experience, but there is something resembling a fast track.
Get paired to a senior programmer/systems engineer
If you have the opportunity to work with a senior on a one-to-one basis, grab it with both hands. There will not be many times when an experienced guy is willing to work with you or coach you, so rejoice when the opportunity presents itself, take it. A colleague of mine asked me which project he should take: a glamorous one where he would be working in a large team with no coaching, or a boring-looking but difficult job, working under one senior programmer. I adviced him to take the latter... which he did, and while he often complained about the job itself, his programming skills improved by leaps and bounds, which made him a senior programmer on the next assignment. I was glad to see he has taken it upon himself to teach in the same manner and spend lots of time with the junior guys.
If construction was anything like programming, an incorrectly fitted lock would bring down the entire building...
It's really funny that the second sentence of the 'Learn to Debug' section has a heinous grammatical error.
Choose no life.
Choose no natural light.
Choose cafeine.
Choose to have RSI.
Choose no girlfriend.
Choose to work long hours and the weekends.
Choose to use C.
Choose to use JAVA after talking to the boss.
Choose to have a bloody big 21 inch monitor.
Choose to comment code.
Choose to have to comment other people's code.
Choose to run a sourceforge project on the side.
Choose to be abused by mindless helpdesk jockeys.
Choose Comp Sci.
Choose D&D geeky friends.
Choose Slashdot.
Choose an early grave.
Choose something else.
Just few quotes:
There once was a master programmer who wrote unstructured programs. A novice programmer, seeking to imitate him, also began to write unstructured programs. When the novice asked the master to evaluate his progress, the master criticized him for writing unstructured programs, saying, ``What is appropriate for the master is not appropriate for the novice. You must understand the Tao before transcending structure.''
Less is more !
I especially like:
There is a lot of room for miscommunication about estimates, as people have a startling tendency to think wishfully that the sentence:
"I estimate it might be possible if I really understand that problem that it is about 50% likely to be completed in 5 weeks if no one bothers us in that time."
really means:
"I promise to have it all done 5 weeks from now."
Heh heh heh...
The script reads like a collections of untruths, half-truths, whinings, myths and philosophical twaddle. The person writing it does not have the experience to write it, nor the insightfulness to realise they should just put up and get back to work. Clearly written after too long a session in front of the glowing tube.
The Glossary is outright wrong; maybe it's the footnote from some SNL show on educational tom-foolery?
This rambling, ill-thought out work would be a terrible handicap to some junior scholar thinking they could read this and jump into the big pot we call IT.
I guess if it gets published the author can collect their royalties. My advice to those that ask me, and many do, will be to avoid this like the plague.
Well, I guess I just sank my Karma!
Another good reference for this type of info is The Pragmatic Programmer. It lays out how to write flexible, dynamic, and adaptable code, as well avoiding traps that a lot of new programmers fall into. It takes the time to explain the "why's" behind a lot of the engineering approaches advanced programmers take. It is definitely aimed at "junior" programmers, though. Usually when we get someone just out of collage, I point them to this book.
Most programmers are not female. Using "She" makes
the work sound peculiar and unprofessional. It
implies a anti-sexist bent which has nothing to
do with the subject matter. Either write things
in passive verse to avoid pronouns, use "they" or
in the few cases where you really need to, use
"he". Anyone who thinks this is sexist has a
problem which your essay is not here to
address.
Actually I think it is a good use of language. His overarching goal for the text is to get you to think outside your normal conceptualizations about programmers. In this case by simply using the female pronoun he causes you to think about a) the stereo type of programmers as nerdy males and b) the way the language we use inherently supports a.
Thinking about how language choice effects function IS something programmers should consider and he elegantly brings this out in the text.
"... programmer does not live in an ideal world. Even if she is perfect, she is sur-
rounded by and must interact with code written by major software companies,
organizations like GNU, and her colleagues."
Yeah, right. Next.
If you happen to work with Java, there are quite a few good commercial profilers around that are really easy to setup and use (such as JProfiler or Optimizeit). Try working with one of these for some time and observe how your way of programming changes for the better. Most importantly, you learn not to pre-emptively "improve" performance - one of the deadliest sins of programming which is responsible for a lot of bad and unreadable code.
...Is to use this site as your programming bible :-P
It is a *must* read for any budding or experienced programmer! (You might split your sides from laughing too much).
Are you local? There's nothing for you here!
I agree with the poster above, but I would like to add a twist. I have found that few successful programs are successful at simply programming. To be truely successful, you must be good at learning to program.
It doesn't matter how much you can do or have done. The market for programmers will always be in untested areas doing the impossible, or at least the highly improbable.
In the end, your actual training and experience is bunk, unless it used as the basis for learning more. The truely gifted programmer does not build static project. He or she builds a tome of routines and knowledge that are the foundations for code used decades later.
Meditate on this, Grasshopper
"Learning is not compulsory... neither is survival."
--Dr.W.Edwards Deming
I like this quote from the document:
"Life is too short to write crap nobody will read. If you write crap, nobody will read it."
As I read through the comments here, it's apparent that virtually none of the posters clicked on the link much less read the document, and a good 90% of them didn't even read past the posting title.
Anyway, the article touches on good points, but it's very clear where the author has personal experience with something and where he doesn't. Some of those times he starts to sound like the books he recommends (all excellent recommendations). Other times (e.g. 4.1. How To Stay Motivated), he simply states something that would be good, but doesn't describe how it should be done.
He recommends "Succinctness is Power" by Paul Graham. Given the document's spottiness, he probably should've gone alnog those lines instead. Written down a little ditty about why you should read the material, and then his list of books and articles to read on how to be a programmer.
If half of the programmers I've known had read his recommended list, I'd have a hell of a lot more trouble staying far enough ahead to have time to review articles and post on slashdot.
It looks fairly sensible, but the main problem is that (1) good programmers know these things and (2) bad programmers usually can't or won't learn. This makes the audience pretty narrow, i.e., inexperienced programmers with decent raw skills.
And this bit made me laugh (2.5):
What do you do when you start to run out of low-hanging fruit? Well, you can reach higher, or chop the tree down.
It just seems like a funny metaphor (picture it in your head, chopping down the tree is sort of overkill just to get more fruit :), although I understand what he's getting at.
czth
I've been coding in an enterprise environment for quite some time now, and I have one rule that is cast in gold:
Always optimise source code for legibility above all else. Never trade legibility for performance unless you have no other choice, and then document your cleverness in the code so that those who follow behind you can keep up.
Here's why:
When you first write a system, it will spend its first few months of life in a very intensive quality control feedback loop. Bugs are found and very quickly exterminated. The code is still fresh in your mind and you're "in the zone".
But as the system stabilises, there is less and less reason to go back to the code, so that freshness wears off. After a little while, other priorities will take over and the internal model of the code will fade away.
But there's still bugs in there - there always is. But any bug that makes it past the first few months is non-obvious, intermittant, rare, and so on (thus, harder to find)
When one finally surfaces, _somebody_ is going to have to fix it. Sometimes it will be you, and you will appreciate code legibilty when you have to dust off source that has laid untouched for years. Not only does it increase the probability that you'll be able to actually find the bug, it cuts down on the time needed to fix it.
There's nothing like being the guy who finds and fixes bugs within seconds of them being pointed out to enhance your reputation.
But more often than not, it will be some other poor sap who gets saddled with your code and a deadline to get it fixed - and the guy who draws the short straw is normally not the biggest brain in the shop. There is no gratitude like the gratitude from someone forced to dive into somebody else's code, and who subsequently discovers that you have gone out of your way to make it easier for them to understand.
This is _also_ a reputation enhancer. "That code was so well written that not only did it take no time at all to track down the bug, but I also learned a couple of new techniques in the process!"
The true guru is a TEACHER.
Oh, and ALWAYS check the return code from every system call and provide appropriate error trapping. That's good too.
DG
Want to learn about race cars? Read my Book
Be prepared to be wrong.
Be prepared to be proven stupid, to go in the wrong direction and have to forget it, to bust your ass for weeks only to discover you're doing it the dumb way.
Be prepared to take criticism at this point, to learn the right way and actually practice it, to laugh at yourself and to not gloat over your fellows when they make the same mistakes. After all, the next time you do something dumb, they're the onces who will be pointing it out.
These are skills that will get you by in any field, but in programming they'll save your ass.
Hey freaks: now you're ju
4 years ago, I (Mechanical Engineer, major in Design Engineering) was involved in a bigger software project: Building a modular simulation system for vehicles, based on a database and a Multi-body code with output to Excel and lots of fancy stuff in between to make it all work. Since the customers and users were the people from our Design Dept, i.e. Engineers, I asumed that they would have thought through all the specs and that we basically just had to start.
Big mistake! Being good and great Design Engineers in the mechanical and electrical domain, regarding software they were as clueless as any Marketing Drone. Whenever we tried to extract specifications, all we got was "make it work like that old APL code we have, but better and more modern and let is calculate/simulate more correct results". Aaaarrrrggggghhh...
Unnecessarily to mention, that only very few actually knew how the old system worked and under what assumptions it was built.
Well, we boxed our way through and today I am the only person in the company that has the total insight (the other 2 left). Unfortunately, we were never given time to properly document the system (of course the code itself is quite well documented but there is more to do than just that). In my naïvité I thought that the Design Dept with their fixation on drawings and Supplier Specs and Purchase Reservations and Engineering Change Notices should understand the value of proper documentation...
A reflection I can now make: Hiring us Design Engineers to make the work instead of professional Software Engineers was probably the only way for the company to get the job done within reasonable time & budget. Non-existent specs, poorly understood assumptions for certain calculations - what a nightmare for any professional software developer!
Excellence: Moderate (mostly affected by comments on your karma)
I have to agree. Why can't people just accept that in English the pronoun "he" is used for both male and undetermined gender. Instead, the author uses "she" as a pronoun, which, in normal, non-PC usage, refers only to females. It annoys me to the point of distraction. At the very least, he could have used "he or she" or, if that would add too much to book length, "s/he" might have been a more acceptable alternative. Personally, I avoid buying books where the author is obviously trying to be PC just for book sales, especially in a male-dominated industry.
Real software engineers regret the existence of COBOL, FORTRAN and BASIC.
Like any profession you're born with some inate abilities to do things which schooling can then direct and improve towards being skills you can use to make a living.
Some people are born to be athletic but without the proper training those people will never reach their full potential and make a living out of it.
Ben
Work Safe Porn
It's true! My cousin was finger painting in BASIC when he was a baby. When he turned three he hacked his Etch a Schetch to run Linux. He's seven now and he is writing his own OS! ;)
How elitist of you.
Good programmers aren't born that way, they learn to be good programmers. Most "bad" programmers can be taught to be good programmers and those that teach them how are usually "incredible."
From your attitude I'd guess you're a bad programmer because you think most of your co-workers are bad (can't be that you're bad, everyone else sucks). Since you don't need to be told how to program (you already know how and learned everything by yourself), I bet you don't listen to other people well so you're communication skills are lacking.
Some people may be hopeless when it comes to being a good programmer, but 90% implies to me that they aren't the problem (but you may be). 5-15% sounds a little more reasonable (and my experience).
I used to work with someone who talked like you and that person was the worst co-worker I ever had to deal with.
Such sagely wisdom
With anonymity you write
Knowing and unknown.
A feeling of having made the same mistake before: Deja Foobar
I'm sorry, but even I (a female programmer) had to snicker at your Subject line given the abundance of the female pronoun in this article.
Did you pun intentionally?
JoAnn
Personal Skills are more important than most programmers think. With personal skills,a programmer is able to chat with marketing and managers to figure out what projects THEY should be put on, which helps build their skills and keep the job interesting. Personal skills gives the programmer the ability to influence managers to get the good projects. Personal skills will also promote a programmer in the eyes of of management, an equivelent programmer that doesn't communicate with management will be more quickly forgotten when raises are given out.
Don't forget, the squeeky wheel gets the grease.
love is just extroverted narcissism
How many "shes" do you ever see doing GOOD coding? And I'm not talking B.J.s, but real coding, how many?
Some "shes" are good at coding (and maybe B.J's), just as some of us "hes" are good at B.J.'s (and also coding).
I'll see your senator, and I'll raise you two judges.
haha nice troll. :)
I have yet to meet someone that could not be taught to program. And if they are teachable they can become skilled if they are motivated. Sorry to have to be the one to tell you this, but your skills aren't 1337. I could teach anyone with algebra skills to program.
me karma am bad
you end up having very little contact with the softer gender
I don't know where everyone gets this from. Maybe this was somewhat true 10-20 years ago, but not now. Not all programmers are socially inept dorks with no lives outside of computers. Or am I the exception to the rule? I tell women I'm a software developer and it *increases* my chances with them (I suppose they think $$$). Hey, and I've been a geek most of my life--and I still spend much of my free time on computers. Women like a guy who can fix a computer. Trust me. Being somewhat successful in your profession helps also, so reading "How to get a Programmer" will indirectly help you get chicks.
If you're a geek, you *can* have luck with the ladies; especially if you've got a job and some cash to spend. Shave that beard, get a decent haircut. Buy some nice clothes. Go out, drink a coupla beers, and just talk to women. There are ladies out there for everyone. Trust me, they are just waiting for you.
Zoot!
That's because only "shes" need to know this sheet. Guys are already in the know. How many "shes" do you ever see doing GOOD coding? And I'm not talking B.J.s, but real coding, how many?
Actually, one of our female coders writes some of the best code, and I've learned a lot from her and just reading her code.
Zoot!
Probably true, but I felt as I read the thing that the author did not understand that making the sort of gross generalizations they were making they were falling into the very same same holes that all other pontificators on the subject fall into. The understanding of how we work becomes a very personal thing, it is brash move for the author to suggest that THIS IS HOW IT IS.
Hence the Twaddle, myth, etc.
Hope I didn't disturb anyones sleep.
Better yet,
BELGIUM! MAN! BELGIUM!
The biggest clue that the writer has no clue about computer programming is his statement that 50 hour weeks are typical and 60 hour weeks are his limit. If you are writing code for more than about 2 hours a day, you are writing bad code that is horrible and buggy. I always try to explain what I do to people as very complicated math homework. Noone can actually do math homework for 60 hours a week. It is far too draining.
The majority of most programmers days at work is spent processing ideas in the back of their heads while they do other things (like post on Slashdot). The 2 typical tasks in programming, adding a new small feature to an existing program and debugging a bug are about 100 lines of code and 2 lines of code respectively. These would take in theory half an hour and 2 minutes respectively. But as the old story goes, its knowing which $1 component to replace in the $1,000,000 machine that costs the $10,000. So it is in programming.
Knowing how to integrate the new features and bug fixes without horribly ruining the existing design is the mark of a good programmer. Actually coding the fix or feature once it has been designed (on paper or in your head) is trivial. Overworking yourself leads to bad design and more bugs, which take even more of your overworked self to fix. This escalating behavior leads to burnout as well as the human brain can not spend that much time working on difficult problems every single day.
Anyhow, now that my brain has figured out how it wants to implement the new feature Im working on, while writing this comment, its back to work to toss out my 100 lines of well designed code. If my writing seems confusing or poorly structured, its because my brain was working on code design, not paragragh design.
And because he had never read -- because of the extra 2 weeks he took writing that function -- the whole dot com industry collapsed.
Nothing great was ever achieved without enthusiasm
Here's some feedback.
...
... there is even more you can do. Move I/O handling to a seperate thread (more on this in my next comment.)
...)
Re: Divide and Conquer debugging approach
Knowing *where* to split requires less skill than he suggests. While binary-splitting is useful from an algorithmic point of view, in the arena of debugging, there is no reason to be binary. I will typically split the problem many times (8 or more) at each step. This observes the fact that usually the cost of splitting the code is much less than re-running the scenario to test to see which split it makes it past, or fails to run properly.
Neglecting examples in the debugging section is bad. In particular miss-synchronization of multi-threaded applications is an example that should be shown.
Re: 2.6 How to Optimize Loops
Ok, this is a really short list, and it misses the important principle of "caching", and some of the suggestions are wrong, or typically inconsequential.
1. Sometimes floating point can actually be faster than integer code. This is especially true if the code can be completely pipelined. In particular trying to change from floating point to fixed point algorithms in modern CPUs may actually *decrease* performance. The details of this requires a lot more discussion.
2. Inlining will be ineffective if the function routine is too large, or if the procedure prologue/epilogue cost is either low or unremovable.
3. Fold constants together -- you should be more explicit about what you mean here. Certainly sub-expression elimination is a common technique that usually works well (but compilers are pretty good at finding that for you) but in some CPUs like the x86, immediate absolute value operands are practically cost-free. Perhaps he means "hoist" whenever possible? That certain does help.
4. As to moving I/O into a buffer
5. Try not to divide and avoiding expensive casts requires much more detail. The best thing to say here is the understanding these costs requires understanding the underlying machine code that results from these operations. (Floating point division can actually be relatively cheap in the right context, and differentiating between cheap and expensive casts can sometimes be difficult, and require context as well.)
6. Using pointers rather than indicies -- x86's have sophisticated addressing modes wherein there is commonly no difference between these two alternatives.
Re: 2.7 How to Deal with I/O Expense
An important principle to apply is to realize the parallelism via multithreading can substantially assist these problems. For example if some IO is non-negotiable, or non-predictable, then at least it can be blocked, or streamed in a seperate thread. The reasoning behind this is that modern operating systems can yield (i.e., block) program control (i.e., your execution resources) from a slow to respond thread to the faster ones. So you can overlap all your algorithmic work with the delays while waiting for the data.
Re: 2.8 How to Manage Memory
Something should be said about caching versus non-caching. First of all, point out the cached memory can be tens to hundreds of times faster than main memory (in modern CPUs.) Variables on your local stack, and globals that are commonly used in your inner loops, will tend to be cached. However array streaming will tend to de-cache your data.
Running through your streamed data in multiple passes is especially bad, as it will require reading your data into the cache multiple times.
Again much more can be said here.
Re: 2.9 How to Deal with Intermitten Bugs
This is an important topic. Its because it represents the hardest debugging problem. We all run into it sooner or later. Even if it is a hard subject to tackle, it has to be expanded on. Giving examples here are invaluable. You have to show that as hard as it is, it is possible to ferret out such bugs.
Re: 2.10 How to Learn Design Skills.
The biggest thing to explain here, I think, is to just explain that all code can and should have seperate documentation corresponding to it, that is written *before* the actual code is written.
Re: 3.6 How to Work with Poor Code.
Remember that people may be more open, or willing to learn than you think. If you decide you have to recode something for someone, it may be beneficial to be explicit about this and show them the results. But for such a thing to be effective, and to get over any potential ego problems, you have to make sure the rewrite is absolutely, clearly, obviously better (it should be shorter and more easily readable.) Your goal should be to make sure the programmer that is the target of the rewrite, considers the results to be a better approach that is worth emulating themselves. (Give a man a fish
Section 3.7 needs to be tied to the last paragraph of section 2.1. Scribbling over some "pristene" (sp?) code is irrelevant if you can easily recover it (which you can with good source control.)
Re: 3.8 Unit testing -- my experience with this is a bit depressing. Unit tests always start out being a good thing, but over time, they are an extreme PITA to maintain. Unit testing is a good thing for what I consider *totally generic modules*. The reason being that truly generic modules do not evolve over time, while other code invariably does.
Unit testing can only be effective if there in an enforced automated testing mechanism. I.e., a failure causes an automatic and non-negotiable rejection of code checked into the tree. I have found it remarkably difficult to convince people that such a policy is worthwhile. (SGI used to use such a mechanism, and, of course, it worked wonderfully for them.)
Section 3.9 and 2.4 Belong together. How is 3.9 a team skill?
Re: 5.2 How to Manage Third Party Software Risks
In my experience, this is trivial -- rely on track record. Its more indicative than anything else. If the software has already shipped and has a history, then there is no problem. If it has not yet shipped (and you are hoping that it will in time for you to use it), then you are going to get version 1.0 software at best and more likely you are providing a beta test environment for the third party developer. Just put yourself in the shoes of the third party developer. In what way will they maximize the take away from their involvement in a relationship to sell you software? Remember business relationships can tend to dominate technical ones.
Re: 5.4 How to Communicate the Right Amount
In here you write: It costs its duration multiplied by the number of participants. Please underline and boldface this. It amazes me how managers don't understand this.
Re: 6.1 How to Tradeoff Quality Against Development Time
Remember that a good *design* will be resilient against poor code implementations. If good interfaces and abstractions exist throughout the code, then the eventual rewrites will be far more painless. If its hard to write clear code that is hard to fix, consider what it is wrong with the core design that is causing this.
Re: 6.2 How to Manage Software System Dependence
The harps back to a concept I referred to above as *totally generic modules*. These are just libraries that provide useful functionality and can take input without making any non-trivial assumptions, and contains no dependencies whatsoever.
An example of this is the C run time library. A good example that will help make this clear is that the C run time library is able to provide a quicksort implementation without knowing anything about the underlying array it is sorting.
State-less, assumption-free, zero-dependency code is very valuable. Its maintenance and development will be finite in cost, while its utility is on-going. Imagine the cost of rewriting the C library every time you use it.
Impressing this upon programmers will help them recognize the value of reducing dependencies.
Re: 7.2 How to Utilize Embedded Languages
Ony option you seem to have avoided is the possibility of embedding pre-canned languages. The real problem with embedding a language is that useful language design is harder than you might think at first. People's aversion to using/learning it is bad enough, what happens when they uncover a flaw in your language that is fatal to its design? People who design real languages put a lot of work in them, that cannot be trivialized. Whipping up an embedded language is unlikely to yield the most stellar results.
That said, there are currently numerous options for embedded other pre-canned languages. Python, Lua and Ruby come to mind. Before going off on some adventure of trying to design your own language, consider whether or not you are going to be able to do a better job than what you could do by embedding one of these languages. From my personal experience, I can tell you that Lua can be embedded in a few hours, and has probably the smallest learning curve of any language in existence.
How to be a Professional Programmer:
Demand to get paid for your work.
One day a Novice came to the Master.
Master, he said, How is it that I may become a Writer of Programs?.
The Master looked solemnly at the Novice.
Have you in your possession a Compiler of Source Code? the Master asked.
No, replied the Novice. The Master sent the Novice on a quest to the Store of Software.
Many hours later the Novice returned.
Master, he said, How is it that I may become a Writer of Programs?.
The Master looked solemnly at the Novice.
Have you in your possession a Compiler of Source Code? the Master asked.
Yes, replied the Novice.
The Master frowned at the Novice.
You have a Compiler of Source. What now can prevent you from becoming a Writer of Programs?.
The Novice fidgeted nervously and presented his Compiler of Source to the Master.
How is this used? asked the Novice.
Have you in your possession a Manual of Operation? the Master asked.
No, replied the Novice.
The Master instructed the Novice as to where he could find the Manual of Operation.
Many days later the Novice returned.
Master, he said, How is it that I may become a Writer of Programs?.
The Master looked solemnly at the Novice.
Have you in your possession a Compiler of Source Code? the Master asked.
Yes, replied the Novice.
Have you in your possession a Manual of Operation? the Master asked.
Yes, replied the Novice.
The Master frowned at the Novice.
You have a Compiler of Source, and a Manual of Operation. What now can prevent you from becoming a Writer of Programs?.
At this the Novice fidgeted nervously and presented his Manual of Operations to the Master.
How is this used? asked the Novice.
The Master closed his eyes, and heaved a great sigh.
The Master sent the Novice on a quest to the School of Elementary.
Many years later the Novice returned.
Master, he said, How is it that I may become a Writer of Programs?.
The Master looked solemnly at the Novice.
Have you in your possession a Compiler of Source Code, a Manual of Operation and an Education of Elementary? the Master asked.
Yes, replied the Novice.
The Master frowned at the Novice.
What then can prevent you from becoming a Writer of Programs?.
The Novice fidgeted nervously. He looked around but could find nothing to present to the Master.
The Master smiled at the Novice.
I see what problem plagues you. said the Master.
Oh great master, please tell me. asked the Novice.
The Master turned the Novice toward the door, and with a supportive hand on his shoulder said, Go young Novice, and Read The Fucking Manual. And so the Novice became enlightened.
This is right on - the jobs I've been most attracted to are the ones where they asked me the most technical questions. I'm surprised how little of this sort of questioning many people do when hiring. When I'm interviewing people, I try to put them through their paces as much as possible.
I had one engineer help me take apart a vacuum feedthrough, clean it, and put it back together. She jumped right in and did it. I offered her a job on the spot.
It's not wasting time, I'm educating myself.
Anyone else think it is strange that the author has an email address at hire.com and dedicated the paper to hire.com? He also cited the book Extreme Programming in the references. Those two points make me skeptical about the integrity of the paper however the paper is pretty good.
Worst. Comment. Ever.
The grammar fascist agrees.
The basic problem is that there is no unique pronoun to reference objects of undetermined or unknown gender. Any book setting forth rules of grammar will tell you to use the word "he" in those cases. Nearly every work ever written uses this convention, which is why it sounds "weird."
It's training: when we see the word "she," every one of us is used to that pronoun referencing a person with a known gender. Similarly, depending on context, we're used to "he" referencing a person of known or unknown gender. So rather than suggesting a mild anti-sexist stance (which the author is no doubt doing, since he's male), it's doing the following two no-nos:
1) Bringing images of a known-gendered person to mind when the person's gender is in fact not known
2) Causing almost all of us - who are used to the "he" convention - to get distracted trying to rembember that the "she" could also be a "he"
The moral arguments can proceed forever, but those two facts remain. One thing to remember is that they are not necessarily logical when considered in a vacuum, or in the context of gender equality. Consider it in the context of training (from a very, very early age - from when the average human starts understanding words), and it makes sense.
Maybe one of these days we'll introduce a word like "hesh" and it'll all go out the window - after a generation or two.
I got my Linux laptop at System76.
If you think about other people who maintain your code and you make their job easier - then good maintenance of your code begins from you.
But if you think that you are too busy for that then it's a big (and growing) chance that your code is useless and another programmer will dcide: "it's easier to re-write it".
See the thread about JUnit for example.
Less is more !
Unfortunately, common sense needs to be taught because it's not as common as people like to think.
I've found in many cases the blame of bad programmers is on two sets of shoulders:
- Management for not hiring enough senior programmers to teach junior ones and for not allowing time to teach junior programmers.
- Senior programmers for not wanting to teach junior programmers because it'll slow them down or they should figure it out for themselves.
I have no control over the first and I try not to be part of the second. From your comments it sounded like you were part of the second problem, I'm sorry if I offended you and that's not the case.
I, at least, would consider algebra skills to be part of the basic abilities/skills needed to be a programmer.
Life sucks, but death doesn't put out at all....
--Thomas J. Kopp
To be fair, commenting code is a slippery slope.
A little commenting can go a long way to helping someone else understand the system.
A lot of comments can be a burden. Why?
Nobody updates them, and lots of people don't read them. Additionally, it takes a long time to write lots of well-written comments - time that is usually better spent re-architecting the system to make it easier to understand.
Every day I come to realize more and more that comments are, on the whole, a waste. Sure, a little comment here and there when something non-standard is going on, or unintuitive. But it is neither feasible nor necessary to comment all the code in a large system - just write better code!
Note that this is NOT meant to say that documentation is worthless. On the contrary, in my experience, the most useful documentation is that which describes the system as a whole, the assumptionst that are made, how the subsystems interlock, etc... Those are things that are not easily gleaned from code, no matter how well written.
Additionally, lots and lots of comments get in the way for the coder navigating the source. It can be a serious slowdown if comments are used too much.
Don't comment, but DO document.
Your employer may make widgets, or run delivery trucks, or process financial transactions, or manufacture cars. Your goal is to help in that process.
Programmers can have a tendancy to be easily "disconnected" from the mission of employer, and can think the goal is to write some cool Java, or to make the source code library work better. Yes, that's the job at hand, but it's not why they pay you each month. They pay you to help them build cars and sell them at a profit. It's an important thing for programmers to have at least somewhere in their conciousness.
Who is enamored with SQL.
You have selected a certain case where it may make sense to use SQL, however, you have missed the large picture, since it is absoultly pointless just to move some data.
Part of the decision you need to make is where to partition the process(es). How much should you do in SQL, how much should you do in C, how much should you do in whatever and so forth.
All of this depends on which system you are developing, who your users are, and how you are planing to administrate/upgrade. There are more reasons to use something else than SQL.
In general I thought that the author's heart was in the right place, but I thought that the text needs work in some areas - especially if this article is supposed to be read by novice programmers.
For instance, the section on Source Control boils down to "Source Control is good. I use it all the time". Why not describe what Source Control is, give arguments as to why it is useful, and give some tips on how to use it to its fullest potential.
There are other sections that need similar fleshing out, beyond just the mere mention.
Also, I would play with the ordering of things. It doesn't quite seem right to dive right into a detailed discussion of debugging at the beginning. I think it would be better to take on some of the more general issues first in order to ease into the technical stuff. Alternatively, you may want to split the article into two. One which discusses the "soft" issues, like working with teams, etc, and another which discusses the more meaty subjects like logging and code comments.
Anyway, best of luck to you in your endeavors.
------
www.moneybythenumbers.com
One of the two reasons I used "she" is to try to make the reader's visualization of the person being talked about a little more vivid.
The article recommends against comments in code using the usual lameass excuse:
Code and comments might get out of sync due to maintenance
Hogwash. Try maintaining code you yourself wrote 10 years earlier and see if the egotistical horseshit that "reading the code is all you need" for documentation is as true as you think...
On second thought, nevermind... come back and read this in 10 years after you -have- 10 years of experience!
Guys, there is no holy grail guide for being a good programmer. It's all down to a person's abilities to understand the system overview as well as the local details of each subsystems and how those subsystems corellate to each other and how they affect the overall progress of the total system.
I've seen quite a few programmers. The best ones are those types that are really interested in the programming concept, and what makes a program beautiful. Once these concepts are understood, then the programmer ceases to be interested in using the latest and greatest features of the underlying development environment and only cares to leave behind a system that works, is easy to expand and debug and easy for others to understand.
A key point to being a good programmer is understanding why an API is bad or good and why the programming language X is better than the programming language Y for project Z. I may not be a good programmer, but I really understand why MFC sucks and why WxWindows is better and Qt the best; or why Visual Basic sucks as a programming language, C and C++ are difficult languages but the most rewarding and why Java is better for most projects(of course this is my opinion and you don't have to agree or disagree, I just mention it here as an example of the issues a programmer has to understand).
But all these are down to personal interest and abilities rather than some guide that people can follow to become successful. I guess this is true for every profession, but it is more important in programming.
All these have a direct impact on the social aspect of the programmer job. A programmer that cares more about programming than others may initially be more drawn to his/her computer rather than to the social interaction with his/her colleagues, but in the end that person will have a much better understanding of what is going on and be a much better candidate for a job that is higher in the company's pyramid (manager, engineer, architect).
Write using TeX.
-- "The reward of suffering is experience." - Aeschylus
Flame suit on...
;-)
;-P
I found his paper interesting for the most part. It's very helpful in giving new programmers an idea what to expect.
Is it just me, or does this guy seem to have a huge ego? I've worked with enough programmers to know there are good and bad ones, easy going and egotistical ones. He seems to have a pretty low opinion of "non-engineers", by which he means non-programmers as opposed to mechanical engineers, electrical engineers, etc.
My favorite section is "How to talk to non Engineers".
Non-engineers are smart, but not as grounded in creating technical things as
we are. We make things. They sell things and handle things and count things
and manage things, but they are not experts on making things.
They are not as good at working together on teams as engineers are (there
are not doubt exceptions.) Their social skills are generally as good as or bet-
ter than engineers in non-team environments, but their work does not always
demand that they practice the kind of intimate, precise communication and
careful subdivisions of tasks that we do. Their teams are more like groups.
Non-engineers may be too eager to please and they may be intimidated by
you. Just like us, they may say yes without really meaning it to please you or
because they are a little scared of you, and then not stand behind their words.
Non-programmers can understand technical things but they do not have
technical judgment. They do understand how technology works, but they cannot
understand why a certain approach would take three months and another one
three days.
It's obvious to me when an engineer has this attitude. They usually come across as cocky and condescending. I find that if you treat your coworkers with respect, and assume they have a clue, that your working relationship will be much better for doing it.
I have a B.S. degree in Comp. Sci. but work as a sysadmin now. Everyone knows that without sysadmins like me, everything would fall apart, and engineers would never get anything done. Ask me how many times I've had to fix an engineer's CVS repository because they didn't have a clue how it worked.
I think engineers/programmers need to have more appreciation for their fellow technical workers. Maybe I'm just being sensitive, but last time I checked, my job required building things & fixing problems (complex server systems, and repairing many system level and code level problems). I also have to do job estimation with a good understanding of the technical merits of different approaches.
And, I hate to disappoint everyone.... but non-engineers are not eager to please or intimidated by you... They might just be too polite to laugh at you to your face when they see how big your ego is getting.
The best engineers I worked with were extremely bright, did an excellent job, and were very good at getting along and working with everyone, whether engineer or sales rep. They were recognized by everyone, technical and not, as our best engineers. Everyone knew they were the core of our company. I would break my back to get those guys what they needed, because they treated me as an peer, and respected my own expertise.
The worst engineers I've dealt with had egos bigger than the buildings they worked in, and chips on their shoulders almost as big. Those were the type I stayed away from. They were also the type that insisted their ideas were right regardless of the facts.
The last jackass engineer/programmer I worked with insisted our company of 50+ people didn't need a corporate firewall "because we use Windows development systems, and Windows software is secure". And this guy was our most Senior Engineer, I am NOT making this up.
Well, thanks for letting me get that off my chest!!
"The author only mentions how to be a decent programmer for your employer. What I want to know is how to be a programmer; I and almost everybody else I know have followed the following steps:" What poeple rarely consider when choosing a school is how well the school does at placing graduates. I had three offers before graduation and I didn't even start interviewing until 2 months before graduation. Of course that was then and now we have a huge glut of experienced programmers looking for work. One word of advice, though, if you are trying to get a job at a small company where everyone wears jeans and sneakers, forget it. Those companies have neither the time nor the resources to train and nuture you. Unless you graduated top of your class from MIT, you're going to have to put in your three years in cubicle hell. If you live in California, consider moving. Washington D.C., where I happen to reside has tons of job opportunities and never fear, the traffic is almost as bad (anthrax and small pox are survivable.) Last of all, get a decent suit, cut your hair, smile, be polite and humble, and read a book on interviewing for jobs. Never, ever BS in a technical interview. Good luck to you.