This question got me thinking about how comapnies deal with newly-hired graduated.

  • Do experienced programmers expect CS graduates to write clean code (by clean I mean code easily understandable by others — maybe that is too much to expect?)
  • Or do significant portion of graduates at your place (if any) just end up testing and fixing small bugs on existing applications?
  • And, even if they do bug fixes, do you end up spending double the amount of time just checking they did not end up breaking anything and creating new bugs?

How do you deal with such scenarios when pair programming and code reviews are not available options (for reasons such as personal deadlines), and also what techniques did you find to get fresh graduate up to speed?

Some suggestions would be great.

  • 3
    This should be expected, whether or not it is. And it should be taught at university. Commented Mar 3, 2011 at 15:45
  • But sadly at Uni I dont think people collaborate with large teams and codebase. Similarly version control and other problems just dont exist. As you might know enthusiastic graduates are all about getting things done quickly waiting for feedback from the tech lead without getting the bigger picture.
    – Simon
    Commented Mar 3, 2011 at 16:15
  • I don't think a large team/codebase affects the cleanliness of new code but, if it does, then the old code is the problem (not the new). Which is not to say that new grads all write clean code and have no other problems, just that there's no reason it can't be taught and expected. Commented Mar 3, 2011 at 16:18
  • 1
    Would be interesting if CS students did work on projects with large code bases. Like a mega-assignment given to the whole year, or maybe rolling from yeargroup to year group. Students would need to make a mandatory number of commits and for the best contributors they could use it as course credit or exam exemptions.
    – Andrew M
    Commented Mar 3, 2011 at 16:25
  • But most colleges enforce the idea of getting the assignment done. Sure, basic clean code is taught in the textbooks in college but the major point was to get your code to accomplish a task and get the end result for an assignment whether you did it in 50 lines of code or 500. Clean code almost seems to have to be self-taught as you progress in college and after. IMO colleges should introduce a course or two focusing on writing clean code and grade it somewhat like English papers, where your graded on content, structure, and readability, not just the conclusion.
    – Adam
    Commented Mar 3, 2011 at 17:01

6 Answers 6


I have found that the best way is to start them on very small projects or pieces of projects, or have them fix small bugs in a larger system. This usually gets them familiar with the "real world" apps, and helps them catch up to the other developers. How long this will to catch them up depends on the individual, and the projects available to them at the time, but seems to usually fall in 1-3 months.

  • +1. This is pretty much how I was started off in my first job. Worked well. Commented Mar 4, 2011 at 22:42

We've had a fair number of interns and college grads roll through here in the last few years, and the first thing we do is sit down with them and explain a few things to them about actual code:

  1. Today you know everything.
  2. Tomorrow, when we let you start coding, you know nothing.
  3. Here is our standards document. Read it and follow it. Keep it handy because you will need it close at hand.
  4. Your code will be peer-reviewed by {X} for the first few months until the nano-bots have completely assimilated your brain.

We keep our code formatting standards in our standards document, and we expect junior new hires to follow it and from time to time have trouble following it as they learn new habits. Our biggest concern is actually the "new" senior developer from company {Z} who has been doing this for 10 years and doesn't need to follow our standards because he does things his way.

If we couldn't do the peer reviews mentioned, we'd have to trust the new guy is following the standard (which we preach regularly). Ultimately, something will be peer-reviewed when the junior has a problem he needs a senior's help on, and at that time pieces will be viewed by the senior and if standards haven't been followed, it will be mentioned and a correction attempted.


It depends somewhat on what people define as 'clean code' - I have yet to encounter someone straight from college who could write clean production code (and that included me over 20 years ago, too). The ability to write clean, production-ready code is not something people are born with, it's usually the result of years of experience and more experienced colleagues willing to spend time mentoring junior developers.

You don't start out a junior developer on a big project of their own (obviously), but normally you give them smaller tasks, either bug fixes (bug fixing is a good way to learn the code base) or implementing small feature requests.

You need to get the code peer reviewed; normally I'd expect that at least one senior developer spends a significant amount of his time with the junior person to make sure they're doing the right thing, writing good code and learning the code base.

If you are expected to throw a junior developer in front of a code base and expect him to be productive without spending a reasonable amount of time with them (because your deadlines fill all your available time), then I'm sorry to say, your management needs a reality check badly. Any new hire will decrease productivity of an existing team, and a junior one that also needs mentoring more so.


Give them small tasks first, monitor their results and give them fast feedback. If their code is hard to read, let them rewrite it until you are happy with it. If you see they lack some fundamental knowledge, organize training or mentoring sessions for them. If they do well, they can get gradually bigger tasks.


Based on some of the assignments I've seen posted to SO and elsewhere, I really don't expect much from new grads because they're clearly being taught bad habits.

IME, new grads and interns are given the scut work that nobody else wants to do; low-priority tasks and cleanup. They get to cut their teeth on relatively simple tasks, learn the ropes as they go, and work with code that's allegedly up to par already so they can learn by example.


For me when I started out I was a tester--->small bug fixer---->writing test applications (in java)---->Started doing Program Automation

It helped not throwing a bunch of stuff at a new person, I mean I was scared enough as it was.

but this helped me get up to speed, and most importantly feel confident about my abilities. Most graduates are ready to start writing big OO code and applications right out of college, my college was good.....but colleges do NOT prepare you.

  • I would have to agree. The only reason I feel prepared for my current job is because I taught myself the programming language I used over 5 years before I even learned it at my choosen college.
    – Ramhound
    Commented Mar 3, 2011 at 18:06

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.