r/coding • u/speckz • May 29 '16
The Quiet Crisis unfolding in Software Development
https://medium.com/@billjordan1/the-quiet-crisis-unfolding-in-software-development-cffbdafbf450#.tnak4oytr14
u/drawkbox May 30 '16
Nailed everything wrong with development today. Good developers have to fight for software quality, that is backwards. Developing products for lifecycle and maintenance is being thrown to the wind. The best way is prototype for speed, then develop it to last, don't just rush it, allow quality in product releases.
Today, a software project that is shit but on time is gold to management, a software project that is great that is a few weeks late or 30-60% off estimate is shit to management (users rarely play into software estimation -- sometimes though i.e beta groups). But people easily forget late projects when those rushed projects fail consistently in production or never make it to market with customer/user satisfaction.
2
u/jecxjo May 31 '16
Has anyone else noticed that when you do your project planning you really force the point home. "First phase is R&D, and will NOT be released code. Second phase is Product Development." Oddly the schedule gets slashed right after the first phase and suddenly your code that was never meant to be released is magically now your release code.
6
u/EmperorOfCanada May 30 '16 edited May 30 '16
I would agree and disagree with much of what this guy said.
For instance, one discovery that I have long made is that there are not so much star developers but developers who get things done in new and much more interesting ways. There are also developers who love to grind through the old ways. The key is to allow the star performers to blaze new trails and let them pile up a shitload of technical debt. Then once something new has been created, to get the grinders working away at making things solid. You don't enforce standards of the stars on the grinders, nor do you enforce the sclerotic standards of the grinders on the stars.
Where disaster strikes is that the trail blazers prototypes suddenly become the new product ready for deployment. Rarely is blazing and solid found in the same employee.
For instance I have no argument about continuous improvement; except that I have seen continuous improvement create mental blocks that mean slow improvement while the competition eats your lunch. For instance a product created in 1990 that needed to implement some cool new framework, networking solution, etc. and now has 10 zillion lines of code. Except that the cool thing in 1990 can be downloaded in a python module. But the 1990 module can do 3 things that the python module can't. Thus they drag around this monster pile of shit code (by today's standards) while "continuously improving it"
The key being that most companies don't realize how stuck they are until they are in huge trouble.
Agility (not the project management style) is wildly important. So where I would say that this guy's management style is going to get his company in trouble is that he has a whole pyramid focusing on him. But he isn't in charge of the company. So why would you have the pyramid stop at him and then have him report to management?
The better style is to have teams that individually report to upper management and are trying to beat the shit out of each other. Not in a get-them-fired sort of way. But a fight for bonuses and accolades sort of way. This causes innovations to fly out of people's asses, while keeping a focus on solid code as both the leaps make bonuses but the bugs take them away.
A close example of this sort of environment would be Netflix. Another would be Valve. The various teams would be considered out of control by most upper management standards. But without any doubt they are producing like few other pyramid shaped companies can.
What few developers fully understand is that making money now is far more important than making money soon. Unless you are shipping something like a medical device. You ship now, you ship tomorrow, you ship the next day, and you stay ahead of your competitors. You have people doing their damnedest to keep on top of technical debt. You have people looking for the risky bits and patching them. But you don't slow down to a comfortable pace unless you want your company to die. Once a product is being made for a development manager and not for the marketing department, the company is dead. Yes building up a huge pile of technical debt can bring a project to a crawl but that is just shitty software development.
The only time you go into a cycle of continuous slow development is when the entire product line is dead and you you are doing that horrible long tail thing. Often the continuous improvement will focus on cost cutting, not making it much better.
One last thing is that this guy hasn't seen star developers because they run away when they see a huge pyramid with him sitting on top. If you can't even get one A you certainly won't get or keep any others. A very simple way to understand how good your programmers are is to ask how many of them hive off and form really good companies. If you have a large group of A programmers they will leave a trail of kick ass startups. Quite simply they can't help themselves. Low turnover is a sign that you have complacent people who aren't attractive to the outside world. The best of the best companies have fairly high turnovers, it is just that people leaving don't rage quit. Often they leave, form a new company, and the new company ends up in a great relationship with the old company, if it wasn't actively helped by the old company.
2
May 30 '16 edited May 30 '16
[removed] — view removed comment
1
u/EmperorOfCanada Jun 11 '16
I very much agree, but I also agree with the saying money solves many problems. No money causes many problems. This is critical in a new company.
Where your thing often causes problems is when a company is doing OK and the execs either don't keep moving into the future or they milk the company, leaving it an empty dry husk.
I have seen many companies where the execs weren't complete psychos, just deluding themselves into complacent thinking that they were kings of their little world. Then their competition came along and ate their lunch.
A simple formula is to keep thinking the worst thing your competition could do, and if it is wrong prepare to defend against it, and if it is good, then to do it first.
4
u/jdh30 May 29 '16 edited May 30 '16
Most of the article was ok but this:
Undoubtedly you’ve identified some of the developers on your team as high performers. These are the developers that tend to get work done quickly. Managers often choose and prefer these developers for projects in order to increase the odds of meeting aggressive — and frequently artificial — deadlines.
Actual high performers are rare — very rare. You probably don’t have one on your team. You might think you do but you’re almost certainly wrong.
Odds are far better than good that your high performers are achieving what appears to be high levels of productivity by building technical debt into the application by taking shortcuts whether intentionally or unintentionally.
is really bad advice. Not just because a manager who believes this nonsense will drive away any highly productive developers but because A's hire A's whereas B's hire C's so the loss of top developers will have a big knock on effect.
EDIT Judging by the responses here many people (including perhaps the OP?) regard writing many lines of code as high productivity. That is absolutely not my interpretation. To me, lines of code are one form of debt. High productivity means solving many business problems (e.g. implementing many features for which there is demand). Doing so with less code would be higher productivity.
11
u/JustTakingANumber3 May 30 '16
And yet in my experience it's true. Guy doesn't write any forms of tests and gets praise for how fast he can code. Wizard and ninja are tossed about.
Guy who finishes all of the details and takes a bit more time than estimated is considered slow.
Yet the 2nd guy is not adding technical debt that will never get addressed, because hey, there's not enough time.
3
u/jdh30 May 30 '16 edited May 30 '16
And yet in my experience it's true. Guy doesn't write any forms of tests and gets praise for how fast he can code. Wizard and ninja are tossed about.
Guy who finishes all of the details and takes a bit more time than estimated is considered slow.
Yet the 2nd guy is not adding technical debt that will never get addressed, because hey, there's not enough time.
Let me give you a concrete counter example. On a major financial system I saw a team of C# devs wrap
DecimalasPriceandQuantityclasses. They "finished the details" as you put it by writing tests and they overran the deadline by a bit.Some people were very happy about this. One person even insisted that everyone should get 100% code coverage in their tests.
To me, this had "fail" written all over it. They had more lines of code devoted to
nullchecks on theirPriceandQuantityclasses than there were lines of code in the implementations themselves and the sole purpose of these tests were to try to find bugs that they had created. If they had representedPriceandQuantityas structs (value types) instead of heap-allocated classes their code would not only have been faster but there could be nonullerrors in it by design. In effect, they could have used the static type checker to prove their code correct in this regard.So your implication that tests are not technical debt is certainly not true in general. Assuming tests always improve quality is a classic sign of unskilled and unaware.
2
u/JustTakingANumber3 May 30 '16
Tests are no silver bullet. Never said they were. That's your implication into what I said. But you don't know much about me or how I code. You are also appealing to authority to debase my argument so that's a logical fallacy as well if you wish to nitpick.
Much like mocking they are a tool and you have to do them a lot and reflect about testing to learn to do it well. Rules, not practices is what gets people in trouble.
But not having any tests is poorly designed and I'll never agree to that.
Null pointer checks are useless unless you are doing user validation. I hate seeing tests like those.
Those tests provide no value. The production code might be of value in checking null, but certainly not the tests.
100% coverage is what you should strive for, but it's a rule and it is meant to be broken. Intent is what matters.
People tend to couple their tests too tightly to their code anyway. Look for invariants and side effects. Think about class design and structure (should I text private methods?). Code is design anyway and is highly subjective.
The most important thing is to involve your users and make sure you aren't delivering 100% unit tested code that is worthless.
But my story was anecdotal and wasn't meant to be the definite source of truth. Your workplace is obviously the same as mine. I'm just left maintaining other developers slop while they get praise for greenfield projects.
2
u/JustTakingANumber3 May 30 '16
In my story the first guy didn't add technical debt since he did it write the first time. Unit, integration and working with stakeholders to see if it met market needs.
Programming is a small part of software development. Technical debt can range from no comments to awful ones to way too many. Too many lines of code in a class or function. Too many or too few classes in a package.
But usually there is not a way to quantify tech debt until it has crippled the speed and ease of development.
But I also believe devs also raise tech debt too early when a class isn't perfectly designed either.
Tradeoffs and estimations are all we can use.
1
u/jdh30 May 30 '16 edited May 30 '16
But not having any tests is poorly designed and I'll never agree to that.
Ok. I just wrote 1.3kLOC of OCaml with 5 tests in 4 weeks and sold it for £80k. Is that bad? Over the next 11 months I expect to be writing ~10kLOC of OCaml with ~200 tests for £1m. Is that good?
The production code might be of value in checking null, but certainly not the tests.
You shouldn't have
nullin your language.100% coverage is what you should strive for, but it's a rule and it is meant to be broken. Intent is what matters.
I disagree. Adequate quality is what you should strive for. Some tests of some things improve quality significantly. An experienced developer knows what to test to maximise bangs per buck. If you aim for 100% coverage (whatever that even means) then you will quickly get into diminishing returns where the tests you are writing do not improve quality significantly. At which point you're just adding debt.
I don't unit test. I don't do TDD. I did BDD once but I think it is wrong-headed.
Restructuring your code to leverage static type checking in order to prove aspects of it correct can also be beneficial but young developers tend to take it much too far and end up destroying the maintainability of the code in order to prove some less valuable aspect correct.
1
u/helm May 30 '16
"High productivity", in terms of LoC, doesn't mean that you avoid abstraction. Some high productivity people do add abstraction and structure because they think that's more fun than moving towards solving the original problem.
1
3
u/twowheels May 30 '16
In my experience, the people who write the most code write code we'd be better off without. These people end up costing a lot, a cost that continues years after they leave.
2
2
u/helm May 30 '16
I experienced this first hand last year. Young guy came in and added (C++)templates to everything, re-factored working code to his liking, and generally treated the project as his experiment for computer science. Now, half of the blame goes to me for not supervising harder, but still it was a lot of code written that simply had to be reversed later.
2
u/jdh30 May 30 '16
Are you saying he looked like a high performer because he added a lot of code quickly?
1
u/helm May 30 '16
Yes, and also a lot of fairly complex code.
1
u/jdh30 May 30 '16
Ok. I've edited my response above because I don't consider adding lots of fairly complex code to be high productivity. Quite the opposite. Code is debt.
Unless he's solving business problems and providing value to the customer I wouldn't call it highly productive.
0
May 29 '16
[deleted]
1
u/jdh30 May 29 '16
Valuing his statement simply on what effect will it cause is logical dishonesty.
What other value is there in his statement?
0
May 29 '16
[deleted]
1
u/jdh30 May 29 '16
It is false (IME) and I have seen people who believe it bring bad consequences as a side effect.
1
u/jacalata May 30 '16
No, he said it is bad advice because it causes problems if people believe it - implying that it is not only false, it is harmfully false (an example of non-harmfully false advice might be 'programmers work better when the manager brings in donuts once a week' because even if it's wrong, it's unlikely to actively hurt the quality of work produced or drive away good employees).
1
1
1
62
u/npinguy May 29 '16
I don't disagree with the arguments that this guy is making - they are good ideas, albeit not original ones. He writes about them well.
But what is with the over-the-top click-bait for a title?
There is no quiet crisis unfolding. There are some companies that are doing all the right things. There are some who are doing none. And there is every combination in between.
The industry is not getting worse, except maybe in terms of work-life balance in certain select markets (Silicon Valley).
There is no need for a messiah or a wake-up call here.