4 ms·
> A lot has been written about "hyperproductive teams". ... there’s one thing in common between all the stories I’ve heard and the successes experienced first h
by dahart 8y ago
> A lot has been written about "hyperproductive teams". ... there’s one thing in common between all the stories I’ve heard and the successes experienced first hand: small teams
Personally, I'd go one step further. It's small teams that were together from the start. Going through the initial setup of a project makes all the difference. When people come later, they lack the intuition that comes with being around when all the structural decisions were made. Early people make tradeoffs and bake good and bad practices into the pipeline, later people are told not to touch certain things because it's more complicated than it looks or will break something else that doesn't seem explicitly connected.
I've been on both sides of this fence. Having started a company and sold it - my partner and I were hyper productive, but while the small team that inherited the code is extremely capable, it took years longer to feel comfortable making big changes than it took to write.
Joining other people's projects and large codebases, on the other hand, has always taken a long time for me to be productive in. Typically it takes a year at a new company before I'm moderately useful.
Personally I don't think this has a ton to do with programming languages, even though I feel much more productive in python and javascript than C++ myself, even though I've been using C++ longer. I still suspect familiarity with the early decisions is a greater factor in productivity than language.
- brightball 8y agoPart of that is the difference from having a system with paying customers vs a new system still trying to gain them. Risk for changes increases with success and for devs who don’t own the company they can’t make hard calls as easily.
- dahart 8y agoI would have to agree with this wholeheartedly, thanks for adding it. Yes, risk tolerance drops over time as a business solidifies, and hyper productivity is partly a function of high tolerance for risk. Risk tolerance goes down at the same time that sales and technical debt and complexity and team size all go up, so I think losing the feeling of hyper productivity over time the more successful a company is, is both natural and inevitable.
- mannykannot 8y agoAgreed: On the one hand, the anecdotes in this article are not structured in such a way that allows one to say that it must be the language difference, rather than people issues, that accounts for the difference in outcome. They present less of a conundrum if you don't assume the former. On the other hand, C++ seems to be strictly more complex than Python, and if so, it would not be surprising for there to be cases where the latter can be applied more quickly.
- hinkley 8y agoThere’s another way out of this problem, but you have to focus on making the code dead obvious and simplify the tools for working with it. That work doesn’t just pay off in rampup time. True, people can figure things out quicker. It’s easier for early career developers to transition to senior positions. It’s less likely for someone to vastly overrun estimates for tricky new features when the code is well factored. But it’s also about scaling your company up. When your company gets bigger, you will have more than one project. You need to be able to remove people from project A without killing it, and occasionally bring people back to project A at a later date. These things have been a constant source of drama everywhere I’ve worked where there “wasn’t enough time” to follow my recommendations. The projects grind to a halt and eventually they lose so many of the old people they have to start over. But it’s the same management style so the process repeats.
- Game_Ender 8y agoDo you have any more details on your recommendations?
- mjevans 8y agoAt least one of them will be something similar to: write boring code. Document just a little more than you think you need to (be that in self-descriptive variables or actual comments). Don't get fancy unless actual measured performance dictates it, and when you do so, make sure you document both the why (which test indicated this was necessary) and the how (this is what we did, exactly, to make it perform better).
- pmontra 8y agoGet variable and method/function names right. They matter more than most comments. I remember a code base I inherited if avail > 0: I could never reason well about that. Then I changed it to if available_hosts > 0: and eventually into if number_of_hosts_to_scan > 0: Technically this would be enough if number_of_hosts_to_scan: but it's less clear. I'm not afraid to type long variable names because the editor has autocomplete. I don't type much and I don't make typos.
- caust1c 8y ago> Typically it takes a year at a new company before I'm moderately useful. WTF? What kind of companies are these? How are they successful in the slightest?
- tolien 8y ago> It's small teams that were together from the start. Going through the initial setup of a project makes all the difference. When people come later, they lack the intuition that comes with being around when all the structural decisions were made. Early people make tradeoffs and bake good and bad practices into the pipeline, later people are told not to touch certain things because it's more complicated than it looks or will break something else that doesn't seem explicitly connected. I've also seen this happen and agree with your analysis that it's probably not related to the programming language - it seems more like a problem with how the thought process behind those decisions is (not) recorded. Short of making every project (and the codebase it results in) live for a short enough time to guarantee that nobody new will ever have to look at it, we've got to collectively do a better job of being able to explain the "wtf did you do that?!" aspect of development.
- akavel 8y agoYour last sentence reminded me of "The only valid measurement of code quality: WTFs/minute": https://www.osnews.com/story/19266/wtfsm/ https://www.osnews.com/story/19266/wtfsm/
- pishpash 8y agoA readme (in plain language) in every folder helps a lot. Either that or it's replaying every commit from the start. Maybe tools can be made for this.
- akkartik 8y agohttp://akkartik.name/post/wart-layers http://akkartik.name/post/wart-layers As it happens, my current project that uses it has a Readme in every folder: https://github.com/akkartik/mu https://github.com/akkartik/mu
- tolien 8y agoI don’t think it’s about tools as much as culture - whether it’s a readme, a wiki or a chat log that’s not full of talk about the weather and scones (no, really), people have to be suitably incentivised to work that way. Something that isn’t a customer-deliverable (they aren’t going to directly care if you don’t record the weird business process that led to you implementing feature X the way you did; they don’t have a comparison which tells them that if it was recorded, changes could’ve been quicker/cheaper/less risky) is at risk of being cut as soon as there’s a hint of time pressure to get something out the door. It’s coincidental that doing things in less of a “let’s all get in a room and talk about it for 3 hours” way should make keeping remote workers in the loop easier too.
- akkartik 8y agoPeter Naur has written before about the problems of ramping up new people on old codebases: http://akkartik.name/naur.pdf http://akkartik.name/naur.pdf I think this is the essential tech debt (and so shows up the essential problem with that framing; you aren't so much going into debt as selling yourself into slavery, because the debt will never be repaid). I work on this problem: https://news.ycombinator.com/item?id=19533179 https://news.ycombinator.com/item?id=19533179 https://news.ycombinator.com/item?id=19533139 https://news.ycombinator.com/item?id=19533139
- Scarblac 8y agoNow that is interesting, thank you!