Dumbing down code so it can be maintained by junior devs
-
Why is code efficiency important in a product? For that matter robustness. What is robust code (as opposed to a robust product)?
Munchies_Matt wrote:
Why is code efficiency important in a product?
Why would you want inefficient code in your product?
Munchies_Matt wrote:
What is robust code (as opposed to a robust product)?
Seriously? You set out to write code that is not robust? Why would you do that?
Keep your friends close. Keep Kill your enemies closer. The End
-
Ever been asked to do this? I seem to be encountering this more and more -- the last company I worked for, I left because that was stated explicitly by the CTO as the new policy. What would you do if you were told to do that? And by dumbing down, I mean doing things like avoiding LINQ (except for basic things), metadata, reflection, extension methods, and any of the C# 7.0 language features. It seems that long gone are the days when companies actually invest in keeping developer skills up to par with the technologies the company uses. Or even more amusingly (not) keeping those technologies up to date.
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
Statistically, half the people you know are below average. :) Programmers are no different. Maybe worse. In programming, the mean is well below the median. Web development reminds me of "departmental programmers" that write Excel macros. They can do some pretty good work (from a business needs perspective) quickly, and with limited technical knowledge. The thing is, if you can make it work with "commodity programmers", it makes economic sense. Things have changed a lot. Look at user expectations. Before the web, users used to complain if an app didn't respond within 1/4 second after a button push. Now a user might wait 4 seconds without complaining. The programmer that can squeeze those milliseconds out just isn't as valuable if their cost is much higher and they are not interchangeable with "just any" programmer. That said, there is a difference between "dumb" and "stupid". Extension methods and C# 7 features are all pretty simple and easy to understand/learn. I'd say on a scale of 1-10 they are about a 4. Using LINQ deeply is a little higher and the learning curve can be steeper, but still, once you grasp it, not hard. I approach this using a two-tiered approach. A small set (even just one) of advanced programmers are responsible for building "internal toolkits". Basically, domain specific libraries (wrapped with training wheels and pretty little bows and ribbons). The rest of the team just uses these libraries. It's like in manufacturing. You have your tool-and-die makers, and your commodity (lower-paid) workers that use the tools. Good tools make the workers job simple and efficient, and they don't need to know how to build the tools themselves. Management reduces labor costs and manages risk by encapsulating it in the tool/die makes realm.
-
Munchies_Matt wrote:
Why is code efficiency important in a product?
Why would you want inefficient code in your product?
Munchies_Matt wrote:
What is robust code (as opposed to a robust product)?
Seriously? You set out to write code that is not robust? Why would you do that?
Keep your friends close. Keep Kill your enemies closer. The End
Why does the latest C++ 7 features make for a better product?
R. Giskard Reventlov wrote:
You set out to write code that is not robust?
I asked you to define robust, in reference to a robust product. Do so before making assumptions.
-
Ever been asked to do this? I seem to be encountering this more and more -- the last company I worked for, I left because that was stated explicitly by the CTO as the new policy. What would you do if you were told to do that? And by dumbing down, I mean doing things like avoiding LINQ (except for basic things), metadata, reflection, extension methods, and any of the C# 7.0 language features. It seems that long gone are the days when companies actually invest in keeping developer skills up to par with the technologies the company uses. Or even more amusingly (not) keeping those technologies up to date.
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
-
Heh, it's a cost saving plan. :) If you dumb down the code enough that a newbie developer can grok it you can then get rid of some of your senior (expensive) developers. Or at least you don't have to hire senior developers any more.
-
I hate to throw rain on your perceptions but writing code for the least experienced in your team is what you are supposed to be doing. It is one of the first axioms that maturing developers should be picking up. The idea that you want to write code your own way using whatever complexities you deem fit only drives the cost of maintaining your applications up. If everyone in your team is familiar with LINQ for example, than you should be free to use it. If they aren't than you should be using what they do know in its place unless these team members are provided the time to learn how to use such technologiess efficiently. In addition, code is supposed to be as simplistic as possible so anyone can easily absorb it when it is necessary for new people to pick up on your work. Most of the so called latest and cool technologies are just fluff or junk technologies that do the same thing we have been doing for years with older, more mature technologies, yet far more complex since the younger professionals seem to be masochistic in their outlooks on what makes up good coding techniques. Like with Linux, harder and more complex is seemingly better than simple and intuitive... :confused:
Steve Naidamast Sr. Software Engineer Black Falcon Software, Inc. blackfalconsoftware@outlook.com
I don't mind the most cryptic, tricky piece of code as long as it is also accompany be good comments. I've seen some comment describing the code but not the meaning of it. Anyone call themselves programmer should be able to determine the syntax with meaningful comments.
-
As Iv'e said for years, this so called "Skills Shortage" in the industry, is as a result of businesses own practices, but they never learn, they just keep doing the same things over and over again.
Unfortunately, the bottom line drives that. Businesses are not likely to change until they see ROI.
-
Peter Shaw wrote:
Do I get a pay rise and a position in your office if I'm working the same job as you?"
:laugh: Good one!
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
I'm not known for my Tactfulness, that's for sure :-) Blunt as a brick, and straight faced with it too.
-
Usually the management should be in agreement that in-house training ( or sessions) for developers should be conducted periodically by the senior devs or the software architect, how boring they may be , but it is in they interest of the company to do so.Say the senior dev is on vacation.This could be pro-actively arranged and attendance recorded.This could be done with each major release or milestone of the project. Pluralsight videos or online tutorial are for people starting to code or learning and not even for junior devs.
Caveat Emptor. "Progress doesn't come from early risers – progress is made by lazy men looking for easier ways to do things." Lazarus Long
My small team is highly vertically stacked. Our new management declared we would cross train each other. It is all great on paper, but the stress of learning a departed developer's undocumented code in every silo is palpable. In-house training sessions would be a joy in comparison.
-
Conversely, how does having first-class code help the business, compared to having "mediocre" code? If the end result works, and doesn't require massively more expensive hardware to run at an appropriate speed, then why not? "Simple" code helps the business by reducing staff costs, increasing the pool of potential recruits, reducing "up to speed" time for new joiners ... all these things are helping the business far more than using Linq where it's not necessary. Each new language feature or concept is another thing to learn and get expert in - or not. Keeping things "simple" with a smaller subset arguably allows all staff members to become "expert" in the entire gamut of techniques, and therefore able to pick up and work on any bit of the code, regardless of their seniority / experience. Maybe playing devil's advocate a bit here, but if you look at things from management's point of view, there's something to be said for it. And if it means experienced (expensive) developers leaving in frustration - to be replaced by cheaper juniors - that's yet another win for the bottom line.
The examples given of technologies to avoid are actually in the language to reduce code complexity and do a fantastic job of that. This won't make the code more readable for junior devs it will model the bad habits of the previous generation of programmers for the new generation. More likely this is a policy put in place by a manager who wants to micromanage developers and does not want to keep up with the new language features.
-
1. It would be unprofessional to write anything but the most efficient code possible. 2. How would a junior programmer ever progress if not presented with more challenging code. 3. It would not be possible to determine exactly what each junior programmer was capable of until they were presented with something they could not cope with alone. So how would you know how much to dumb down. 4. If I were a senior programmer on this team, I would take this as my cue to look for another job. 5. If I were a junior programmer on this team, I would take this as my cue to look for another job.
-
You havent answered the question. Is a carpenters job to make furniture, or to use the latest saw, plane, and screwdriver?
-
DerekTP123 wrote:
If a junior programmer can understand and maintain every part of the company's codebase, there is no requirement for learning and no requirement for senior (expensive) programmers.
Because eventually, no senior dev will want to work for the company, leaving junior devs to maintain a code base that is metastasizing into an umaintainable, bug ridden slimy blob. At which point management contracts an outside job shop to come in and rewrite the software because a) it's broken and b) it can't support the demands of the users.
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
...and then management changes as the management cannot build the product, and new management begins the process all over again. :((
-
If you are told not to make use of good LINQ or extension methods, I do not think the resulting code would be any easier to understand. If in these cases the code is well commented, it is, in fact, compact and easier to understand. OTOH I agree with reflection (people tend to steer clear from it stating it is too powerful for its own good :laugh: ) since not many people know it. Asking developers to "dumbed down" code shows the lack of trust(maybe they have their reasons) in the new recruits. I do not think the code is the problem here. I would suggest educating the newer members of your team at least the "features" that are commonly used in the project.
I am not the one who knocks. I never knock. In fact, I hate knocking.
Even those of us knowing reflection normally avoid it if the performance hit is unacceptable.
-
Why does the latest C++ 7 features make for a better product?
R. Giskard Reventlov wrote:
You set out to write code that is not robust?
I asked you to define robust, in reference to a robust product. Do so before making assumptions.
Munchies_Matt wrote:
Why does the latest C++ 7 features make for a better product?
I never said that it did.
Munchies_Matt wrote:
I asked you to define robust, in reference to a robust product. Do so before making assumptions.
There was no assumption - just an inference based on your patronizing. The point here is to encourage engineers to write the best, most robust possible code. That does not necessarily mean using the very latest but most engineers will make it their business to both know about the latest developments and how they might fit it into their programming. You are welcome not to do that or to scoff at the idea of writing code that may cause junior devs to actually have to think and learn but they will not improve unless they challenge themselves. Writing dumbed-down code is dumb.
Keep your friends close. Keep Kill your enemies closer. The End
-
soulesurfer wrote:
So, for balance, let's look at the other side.
You definitely have a point, and I will definitely veer toward maintainability. However, it really isn't about code (even though my subject line says "code") but about a lack of training, much with regards to what has been around in the .NET framework for years. Even common practices like DRY, writing small functions, decoupling, etc., those are things, as you say, a junior dev learns through code reviews (not just their own code but the code the senior devs produce) but such code reviews are completely lacking. :sigh:
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
It has been 20 years since I worked at a company that allowed code reviews. $$$
-
Ever been asked to do this? I seem to be encountering this more and more -- the last company I worked for, I left because that was stated explicitly by the CTO as the new policy. What would you do if you were told to do that? And by dumbing down, I mean doing things like avoiding LINQ (except for basic things), metadata, reflection, extension methods, and any of the C# 7.0 language features. It seems that long gone are the days when companies actually invest in keeping developer skills up to par with the technologies the company uses. Or even more amusingly (not) keeping those technologies up to date.
Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
This sounds like a "Negative Brag" to me. You are SOOOO MUCH SMARTER than the other guys you work with (please read sarcasm into this statement). Working as a successful employee includes more than being good at your particular skill, which I am certain that you are. No sarcasm intended. Working as a successful employee, please include contract labor, independent contractor, etc. in this category, involves much more. It includes being a team player, communicating well with others, following requests from your superiors willingly and cheerfully, and yes, that last means "doing it their way". What good is writing code using the "latest and greatest", "Most Robust" tools, frameworks and techniques, that no one else can understand, when in our industry as you well know most of those things will have the life span of Mayflies? Where will the company employing you be when you have moved on to your next contract, or job, and they are left with code you developed, that few programmers / developers understand? They aren't paying you to be a great programmer, they are paying you do get the job done the way they want it done.
"Newer" is NOT automatically better, only Different. (And more complex and bug ridden when it comes to all of the "boutique" languages / frameworks out there) It's a random chance Universe and we are all out there surfing waves of probability... Schrödinger's Cat
-
Nice try. Unless the company doesn't plan to stick around long. Sooner rather than later that simple saving will come back to bite the rear end good. Happens all the time. Think it is expensive to invest in good engineering, try a bad one. :wtf:
-
1. It would be unprofessional to write anything but the most efficient code possible. 2. How would a junior programmer ever progress if not presented with more challenging code. 3. It would not be possible to determine exactly what each junior programmer was capable of until they were presented with something they could not cope with alone. So how would you know how much to dumb down. 4. If I were a senior programmer on this team, I would take this as my cue to look for another job. 5. If I were a junior programmer on this team, I would take this as my cue to look for another job.
Member 12364788 wrote:
It would be unprofessional to write anything but the most efficient code possible.
Really?? Agreed, "efficiency" is certainly in the mix of attributes that a professional coder should aim for; but as the overriding consideration (implied by "most efficient possible") is surely not right. I would certainly be reluctant to deliver the "most efficient" code if it meant that it was virtually undecipherable by anyone but a guru-level developer; or was so rigid that a minor change to requirements would result in a total re-write. And coding purely for efficiency can certainly sometimes result in these types of solution. There are of course (at least) two sorts of "code efficiency": execution efficiency (minimising elapsed time and/or other resources during the usual execution route) and source efficiency (minimising the lines of code / method calls etc). These days hardware resources are typically very cheap compared to developer / maintenance costs so businesses will often opt to develop a simple, maintainable, and/or quickly-developed solution and offset any inefficiency by buying a few extra MIpS or MBytes. As a (freelance) professional, part of my (unspoken) remit is to fully understand the client's requirement - do they need something mega-efficient (maybe to fit on an embedded chip), very quick to develop, something very flexible to maintain in the future, something that could easily be easily ported to another system (so maybe using a common subset of a tool or language), etc..etc..; and then to develop to meet those requirements. In practical terms, "efficiency" can sometimes mean not adding a dependency to yet another external assembly (or to a specific newer version of an assembly). When I create a new VS solution, the LINQ modules are usually included by default. If a solution requires LINQ then I'll use it, but I'll try and avoid just a single usage of LINQ as that adds not only a dependency on an extra assembly, but a dependency that any future maintainer knows LINQ. (LINQ used simply as an example here). Also, "more challenging" may mean a more sophisticated technique or concept; but sometimes it just means a new or different syntax. It may "challenge" the developer to learn that additional syntax, without actually "improving" the developer's skills. Instead of learning "better" ways, they just learn "more" ways to do something. It adds to the buzzwords on their CV but just gives them brain-bloat and I've seen j
-
Even those of us knowing reflection normally avoid it if the performance hit is unacceptable.
The times I've found a reason to use reflection have mainly been when using attributes. You can statically load the information into the type itself so you only incur the expense a single time for each class. Works for generics too (cost will be once per unique T). It's really not as bad as people think if you aren't reflecting constantly.
