Can tech obstruct your fundamentals?

This Easter I came across this blog post about The Value Of Fundamentals (highly recommended reading), and it made me think about how and why we adopt new technology. (Maybe I am fond by this way of thinking because I was a martial arts practitioner myself, and highly respect them still.) In the adoption process the problem it is supposed to solve gets lost, and it is used everywhere as a one-solution-fits-all technology. Fundamentals is not as well understood as they should be in many professions, and software development is no exception.

Technology can prevent you from using your basic skills, as "advanced" technology may look like it can solve several of your problems at once. This is sometimes true, but more often just smoke and mirrors. In addition technology brings on a new set of problems (that you will try to solve with workarounds), and sometimes they become a hammer that you'll try to apply to any problem you stumble upon.

This occurs frequently in software development, but it happens elsewhere too, often with computer technology that is supposed to solve multiple problems. Way too often this obstructs the use of basic skills to solve problems. The challenges here can be mapped to other professions, e.g. physicians on large hospitals relying too much on all the available technology rather their basic skills.

Software development has always been ridden by the Silver Bullet Syndrome, and Silver bullets often infers technology that in effect makes us rely on factors out of control of the individual, project, and most important the stakeholders. But it is not only silver bullet technologies that can make you loose sight of real simple and elegant solutions to the most important problems you are trying to solve. Even wellproven and widely used technology may obstruct the view of the problems.

Here are some examples of categories of technologies that often obfuscates simple solutions:

• Frameworks
• Code generators
• Integration technology, e.g. OR-mapping
  

Most of these adds complexity to the solutiuon (but promises an overall general complexity reduction), as they often are very general solutions trying to solve multiple problems. Solving complex problems by adding multiple frameworks to the solution make a very complex solution. This is where fundamentals becomes valuable, and decisions on whether to use a framework should be balanced with using basic skills.

When basic skills are forgotten or not practiced often you rely too much on technology to solve your problems. What happens then is that socalled advanced technology is applied to simple problems, that should be solved applying fundamentals.

What is really bad about using technology instead of basic skills in a software development context is that technology must be maintained throughout a products lifetime. When a technology vendor stops supporting a certain technology, all products relaying on it implicitly receive a death sentence. Products implemented mostly using basic skills has a better survival rate, as it often can be ported to new platforms where technologies on the legacy platform is unavailable. It can be very complex to update 3rd party frameworks if they are interdependant, or the code is invaded by the used technology. The maintenance cost can rise, and if ignored create serious technical debt.

Additionally well written software brings on best practices to newcomers reading the code, and when a skill/practice is questioned it triggers lot more valuable discussions than whether to throw out/introduce some technology. Evolving basic skills is a whole lot more valuable than decisions on the latest fad. Evolving basic programming skills empowers the individual , project, organization and profession. Technology brings on a substantial number of abbrevitions that is impossible to communication with users and stakeholders. Independant of what technologies are involved in your project, keep it out of non-technical discussions. Users don't care, and is certainly not impressed. Software that works, and that evolves with the users impresses. Wellcrafted software is easier to evolve in the long run, rather than fighting with framework/code generators.

So what fundamentals should all software developers master? I can easily come up with this shortlist, but it is not comprehensive or prioritized in any way:

• Central design patterns
• Know at least 2-3 programming languages, and 1-2 of these deeply and you should be acquainted with a scripting language.
  
• Create readable and maintainable code
  
• What is robust code?
• Important concurrency concepts
• Coupling theory
  

So this is a post that promotes the Not-invented-here syndrome? Not at all! Just let programming fundamentals weigh in heavier against e.g. frameworks and code generators. When cost and/or time constraints favor use of these, look at the source code (not only the documentation) and evaluate amongst other things:

• it is well written
• will not invade your code
• not get in the way of creating elegant solutions to your problems.
  

As a pleasant sideeffect you might even learn a technique you are currently unaware of. When you understand how it is written it will be far easier to communicate with the vendor if changes must be made.

When you think about it, technologies come and go but the software industry in general changes at a much slower pace. It is time to shift this balance from praising the latest fads towards improving basic skills in the software development profession. This will make both the software itself, and the programmers, more valuable. Investing in fundamentals should also be incorporated in organizations' learning circle. Finally programming more consciusly with basic skills will contribute to less monocoltures in software, which in my opinion results healthier software.