3 ms·
Supervising junior staff is not where this battle is won or lost. Your development culture is going to have the biggest impact on how those young programmers g
by dkarl 15y ago
Supervising junior staff is not where this battle is won or lost. Your development culture is going to have the biggest impact on how those young programmers go about their tasks. If you want junior programmers to develop well (software and themselves) you need to attend to the culture they take their cues from.
I worked in a near-ideal development culture once. Twice, I suppose. Everybody was humble. Everybody documented their code. Everybody bounced their ideas off someone; even the smartest guy in the office humbly asked for advice and meant it. Everyone was quick to assume that if other people thought their code was confusing, then it probably was. Everyone assumed they should be able to explain their brilliant idea to anyone else on the team and convince them of its value. Most of what I knew about the codebase at those jobs I learned from guys who knew ten times as much as me drawing diagrams on the whiteboard and asking, "Do you think this will work? Or am I being stupid here?"
A junior programmer would naturally succeed at the picture-hanging problem in that environment because they'd approach it the same way the star programmers approached their work: tell other people what they're working on and what they're thinking, and make sure they can articulate and justify an idea before they commit themselves to it.
That's the ideal. Most cultures fall short of that in one way or another. In a completely opposite situation, if the star programmers work in isolation, disdain to discuss their work with lesser programmers, neglect to document their code, and aspire to write code that no one else understands, junior programmers will learn some very unhelpful lessons. This is true even if the star programmers are getting shit done and writing efficient, correctly functioning code, because they're basically (and I shudder to use this word because I don't want to start the wrong kind of conversation) peacocking. They're getting stuff done the hard way and proving they can thrive in a completely unsupportive environment. There's unspoken machismo, which put into words would sound like this: "Nasty opaque codebase? What's wrong, can't take the complexity, little man?" "Gosh, I would have written some comments if I knew some people needed them." That's the kind of environment where a programmer is going to either wilt and do something really stupid because they've already given up or "rise to the challenge" and try to make a drywall saw using a 3D printer.
Take care of the culture: set a good example, promote respect and humility among your developers, and don't exempt anyone from good practices. Then junior programmers will find their way even if you don't have time to guide them yourself.
- stcredzero 15y agoI worked in a near-ideal development culture once. Thank you very much for this description. I find it gratifying and inspiring. Everyone was quick to assume that if other people thought their code was confusing, then it probably was...There's unspoken machismo, which put into words would sound like this: "Nasty opaque codebase? What's wrong, can't take the complexity, little man?" Also, I find this to be key. There is room for raw talent and huge, inspiring amounts of clever -- but it needs to be focused exactly where it does the most good. Let's just assume that one's competitors are in the same league when it comes to intellectual horsepower. Then it behooves one to make sure one's resources are focused where they do the most good. Let the competition dissipate their intellectual powers in developer pissing matches while you quietly outperform them. Of late, I've come around to a radical stance on this. Modulo DRY, one should almost always target one's code to the lowest common denominator programmer on the team -- the newbie. This should probably follow an 80/20 or 90/10 rule. If a bog-standard well informed and competent programmer can't come in and start fixing 80% of your code within an hour, and it's not due to lack of non-programming specialized domain knowledge, then you're doing it wrong. There's room for elegant abstractions and the odd clever hack -- but you only get to have at most 7 of these in any given subsystem, and the code involved should be the minority of your codebase. Clever is a valuable resource. Use it wisely.