5 ms·
A paraphrased translation from Lieutenant General Aksel Frederik Airo from Finland: You need to go to shit-ton of schools to be able to make simple decisions
by theshrike79 5y ago
A paraphrased translation from Lieutenant General Aksel Frederik Airo from Finland:
You need to go to shit-ton of schools to be able to make simple decisions. Otherwise you'll start to invent all kinds of over-complicated solutions.
Everything in war is simple. The guy in the front lines is the one at war. You can't win in a war unless you give simple orders. The people on top need to be able to give commands that are so simple that even the man in the front lines understands.
Everything is as simple as possible. To understand that, you need to go study a lot.
It's not easy to do things the simple way, being clever is the easy path. Knowing when you need to be clever and when simple is enough is what separates experience from greenhorns.
- TeMPOraL 5y agoIt's a nice sentiment... for running a military. Or managing a company with very high turnover. I don't think it maps well to software development. The soldiers on the front lines spent years being trained to obey orders first, ask questions later. This is necessary because they're risking their lives, and explaining to each and every one of your grunts why it's important they do the thing that's likely to kill them, does not scale. You won't achieve your policy goals if your soldiers each decide the war isn't worth fighting, the orders aren't worth risking lives for. Software developers spend years training (or self-training) to use their brains to solve complex problems, which involves continuous learning, constantly making "tactical" decisions, and quickly gaining understanding of the big picture. It's a shame to first filter people by how good they're at complex technical work, and then make them stop using these skills, for the sake of shortening onboarding time.
- k__ 5y agoThis is so true. We need to stop perpetuating the leadership lie in white collar jobs.
- codingdave 5y agoI think you may be misunderstanding "simple". Simple works great for complex software because simple functions and features are assembled together into the fully complex solution. As a matter of fact, that is what makes a great dev - someone who can envision a complex solution, but then break it down into simple programming tasks.
- lamontcg 5y agoIdeally solutions should be as simple as possible as well. The ultimate core algorithm they're wrapped around might be particularly clever / insightful. It might even be mildly awful to wrap your head around -- but necessarily so. But then all the stuff you wrap around that to produce libraries to build into production code / shippable product should be pretty brain dead stupid as possible. That way people who sit down with your code find things all the places they expect and other than possibly the little nightmare in the middle of it, it is all straightforward and readable.
- sorokod 5y agoMaybe not so much to software development, but exactly right to software lifecycle.
- theshrike79 5y agoJust because you're smart and in the front lines, that doesn't mean you _need_ to take the complex route every time. It takes skill to do things the simple way, to know when you just need to get shit done and when you can/need to be fancy. Let's say I want a fence for my yard. The newbie carpenter wants to show off their skills and makes the most beautiful delicate lattice work with intricate fibonacci patterns. An experienced carpenter sees that I have 4 huge dogs and determines that I need a sturdy fence, not a fancy one. This is the way I do things at work: 1) Make it work 2) Make it fast 3) Make it pretty It doesn't matter if you've got the fastest code and the most elegant one-line lambda functions and the most expressive code if it doesn't work first. First you make the simple and boring solution, the one that works. Then you see if it needs to be faster, most times it doesn't. After that, if you have time, you can spend time making the simple code prettier, more elegant and expressive. In 99% of the cases I don't need to go past step 1, the simple solution works just fine.
- TeMPOraL 5y agoOf course. But I disagree with the general sentiment that "clever = fancy", or "a junior may have not seen this technique before" = "fancy" = "bad". A lot of "advanced" techniques and features of tooling exists because they enable simpler code. Simpler, in the sense of better expressing intent, more readable, less bug-prone. For example, a map-reduce on a sequence will typically be simpler than an explicit loop - because it expresses only the things that matter, whereas an explicit for loop also emphasizes irrelevant details and provide opportunities to introduce bugs. And yet, a random junior is going to consider the latter to be "simpler" - but that's only because they're unfamiliar with more advanced programming concepts. The solution to that isn't to abandon advanced concepts - it's to teach the junior to work with them. > The newbie carpenter wants to show off their skills and makes the most beautiful delicate lattice work with intricate fibonacci patterns. Maybe. Regardless, the newbie carpenter will be identified by doing more work than necessary, using less sophisticated tools and techniques. The experienced carpenter will show up with a richer set of tools, and perhaps apply some non-standard technique to put it up and secure against your dogs. He'll be done faster, and tire themselves less. > Make it work / Make it fast / Make it pretty Yes, this is a good approach, and I'd say programming experience manifests itself in the following ways: - A richer set of tools allows an experienced programmer to get the thing to work faster. - Their experience allows them to simultaneously also make the code somewhat fast and somewhat pretty, because quite often, making things fast and pretty requires the same amount of effort as slow and ugly, if you have some experience to help you make the right choices. - An experienced professional will not habitually stop after the "make it work" phase, unless made so by high deadline pressure.
- roenxi 5y agoIf a problem can be reasonably solved with in either a dull or clever way then there is no advantage to choosing the clever way. It is pretty much all downside. > It's a shame to first filter people by how good they're at complex technical work, and then make them stop using these skills, for the sake of shortening onboarding time. Onboarding time isn't exactly the reason, the reason is that the costs of clever code are higher than the benefits. Longer onboarding time is a cost. One of many that come with not using basic techniques. It is a point of professionalism to target the best outcome for a situation considering factors other than how fun it would be to show off the code. If the benefits of complex code are higher than the costs then it gets used. But basic code is generally more effective.
- j_wtf_all_taken 5y ago> Software developers spend years training (or self-training) to use their brains to solve complex problems, which involves continuous learning, constantly making "tactical" decisions, and quickly gaining understanding of the big picture. I'm just not sure that applies to all people working in software engineering (or any job). I know too many that have no desire to actually understand the/a problem or make tactical decisions but just try out ten code snippets from SO until something works, use any plugin that kinda fits their need (without looking at the size of its code base, if its maintained, how flexible its configuration is etc) or are happy to use any framework as long as it tells them exactly what to do (and not because they actually came to the conclusion that's the way to go, but because they are not responsible for anything but the framework is).
- serjester 5y ago>> The soldiers on the front lines spent years being trained to obey orders first, ask questions later. I think you have the wrong impression of the army. Decentralized command is one of the central tenants of American military doctrine. Trying to route everything through layers of leadership leads to an incompetent fighting unit. Unfortunately, this stereotype is hard to shake. As a result the soldier must understand the broader objective and actively question the tactics used to achieve it. If the ground situation deviates from the plan, waiting for orders will get you killed. I would argue software development is surprisingly similar. The difference between a decent developer and a great developer is the latter understand how their work fits into the larger picture. As a result they're able to quickly and effectively pivot to suit the dynamic needs of the business.
- TeMPOraL 5y agoI am familiar with US decentralized command doctrine, which pushed a lot of decision making to the very front lines. But that's a Cold War-era American invention, and 'theshrike79 quoted a Finnish lieutenant general, who fought before and led through World War II. Back then, soldiers had much less autonomy. And even if somebody ported the US doctrine 100 years into the past, so that LtGen Airo could've learned it in France, it probably wouldn't hold, because there was only so much a front line soldier could do with their decision making capacity. Tanks were a fresh invention, most of the world probably haven't seen them. Cavalry was the pinnacle of agility. Artillery was big, bulky, and hard to reposition. Planes were still laughed at. Portable radios weren't a thing yet. Where your modern American grunt is entrusted with the capability to direct howitzers and call down air strikes, the soldiers of Airo's era were just discovering automated weapons, and modes of transport other than "by foot" and "by horse". There was little they could really decide about. In other words: soldiers gained greater autonomy and more sophisticated training when their tools became more sophisticated and powerful. As it should be - as it is, in any sane industry. If there was any officer that said things like, "those Stingers and Javelins are too complex, they'll confuse our new privates", or "why waste your time learning to use night vision gear when you could run with a flashlight and shoot the enemy", or "giving front line soldiers keys to artillery strikes, that's crazy!" - that officer was ignored, as others recognized that people can be trained in doctrine, tactics and operating complex equipment. > The difference between a decent developer and a great developer is the latter understand how their work fits into the larger picture. Strongly agreed. But 'theshrike79 wasn't talking about that. They were talking about managing men who weren't given the insight into larger picture, because there was nothing useful they could do with it anyway. That was true for the military then. It isn't now. It also isn't true for software development - but there's this persistent trend to make it true, to turn us from modern fighting force into a 17th century line infantry.