And how it's a lifelong journey

Photo by Motoki Tonn on Unsplash Photo by Motoki Tonn on Unsplash

"You are always a student, never a master. You have to keep moving forward."

  • Conrad Hall

There is no one path to software mastery. There isn't a definitive guide to perfection, or a certification to make you great. No. Like any skill, software mastery is about wisdom and its application.

In this article, I'm going to talk about what it takes to gain mastery over software and why, in reality, there isn't a way to achieve it, at least not by objective means. Instead, we're going to talk about the journey and what the moment looks like when you realize you are on the road that many never see.

Is Programming Truly a Skill?

When we say software, we think programming (at least I do). Is software engineering itself a skill? What about programming or developing software?

I would argue that these are not skills in themselves. Instead, programming and development is a categorization of different skills, that a developer or engineer utilizes within their profession.

Let's take, for example, learning a language, like .NET C#.

Now, you have read all the books on C#. You know everything about the following:

  • Conditional Logic: If-Then-Else, Ternary, Switch
  • Loops: Do-While, For, For Each, Recursive functions
  • Object Orientation: Polymorphism, Encapsulation, Abstract Classes / Interfaces
  • Meta-Programming: Reflection, Custom Attributes, Extension Methods (kind of)
  • Interfaces: ASP.NET MVC, Razor Pages, WPF, WinForms, CLI
  • Testing: xUnit.NET, nUnit, MS Test
  • Database Connections: SQL Server, MySQL, MongoDB, Entity Framework, Dapper

And the list goes on. You know everything up until C# 10.0 and have them memorized. You can write C# in notepad and compile it with command-line utilities without touching Visual Studio or VS Code.

Would you say you have mastery over C#?

Well, if I knew all of these by heart, I would absolutely say yes. I have mastery over C#. But the question is do I have mastery over software?

And if this is all I knew, I would flatly say No.

A little while ago, I wrote an article called, "Following the Rules as a Developer," where I specifically go through the Dreyfus Model. I won't retell the whole article, but the premise is this,

The Dreyfus Model is a model of skill acquisition through formal training and practice.

Here are the five levels of the Dreyfus Model:

  1. Novice (Beginner): Novices need recipes
  2. Advanced Beginner: Advanced beginners don't want the big picture
  3. Competent: Competence can troubleshoot
  4. Proficient: Proficient practitioners can self-correct
  5. Expert (Mastery): Experts work from intuition

I would say that the individual above has a mastery of C#. However, there is a lot more that goes into software than language mastery. In fact, language is probably one of the smaller aspects (if not the smallest) of mastering the art of software. Mastering a language is a prerequisite to starting your journey.

So, to answer the question,

Programming is not truly a skill

The Skills of Software

I have claimed that "Programming" itself is not a skill. I don't say this because I believe that writing code on a screen isn't a skill. It is. That's the language skill we talked about above. But would we hire a programmer that was an expert in a language but couldn't do the following (and I mean not in any capacity):

  • Name variables appropriately. All their names are gibberish.
  • Wrote hundreds of classes and functions in a single file.
  • Inconsistent with line breaks and braces.
  • Didn't understand the basic aspects of ASP.NET controllers and used objects for all requests and responses instead of true models.
  • new'd up all classes instead of using a proper inversion of control framework, even the built-in one in .NET Core.

Well, you might hire this person, but I wouldn't. That's because software and programming is more than the language. Much more.

Software mastery requires a lot of skills; Skills that some "programmers" may balk at having to learn. To have a mastery of anything, there are deep fundamentals that are required. This isn't to say that individuals cannot mimic good software practices and write great software. Of course, they can. And for many companies, this is perfectly fine. But it isn't mastery. Mastery requires a deeper understanding of the hardware, operating systems, and overall philosophy of software. And it isn't easy.

But this can be a lot to take in at once.

So, let's start a bit smaller. What skills get me on my journey to Software Mastery? Let's start with this list of skills to master:

  • Language of Choice: Master a language of choice. In my case, I'm partial to C#
  • The framework of Choice: Master a framework of choice. In my case, I'm partial to .NET 6.0+
  • Readability: Master the ability to write code that is readable by all developers; Code that is understood and well organized; Files are clean and in proper folder structures and assemblies.
  • Abstraction Design: Master the art of writing abstractions and interface-based design practices. Understand the minimization of interfaces and their utility.
  • Design Patterns: Master the design patterns and know when to use them and know when not to use them. Understand how some can be mixed and mashed to form a better API for development.
  • Documentation: Master the ability to write strong design documentation and collaborate with others. Although code itself can teach a lot, abstract concepts can be hard to grasp. Learn to teach other developers about it through various forms of documentation.
  • Architectural Patterns: Master the various architectural patterns and know which work in different situations and which will be a hindrance.
  • Operating Systems: Master your understanding of your operating systems where your software runs. Understand how processes are managed and memory allocation is handled. Without this, solutions are hard to find in the field when problems arise.
  • Hardware: Master your understanding of the hardware your software will live on. Does it work with Storage Area Networks (SAN), or does it utilize local storage? Is the environment virtualized or containerized?

The list can go on. Each of these "skills" or knowledge centers can be mastered and should be mastered as a part of software mastery. Now, I admit that mastering hardware isn't necessarily a skill. But even just a strong understanding of its underlying workings changes the way in which we can approach software.

Can Software Be Mastered?

Now, can we truly master software? I would argue that you can never truly "master" it, at least not in the objective sense. Instead, mastery is a form of subjectiveness that is bestowed upon yourself from others.

Like wisdom, mastery is about your ability to judge situations. It also has a level of humbleness required. If I think of myself to be the best programmer to ever live, but my teammates don't trust me in their code, am I the Master of Software?

Not really. What's the point if no one trusts you?

The Chinese's name for the master is "Shifu," meaning "teacher," "master," or "father." This implies that individuals will follow you because of your teachings or mastery of a trade. So, if others do not respect or follow your teachings, you cannot really call yourself a "master" of anything.

But, hey, you can comment below and say you're a "master of software." Unfortunately, that's not really how it works.

So, can software be mastered?

Yes and No. You can be bestowed the title. But it cannot be achieved.

Look at some of these masters of their craft:

  • Ada Lovelace
  • Linus Torvalds
  • Dennis Ritchie
  • Robert C. Martin
  • Martin Fowler

We follow after them. They laid the path for us to move forward in computer science in many ways. There are many more than this of course, but we would probably consider them "Masters of Software."

Are there other unknown developers and engineers out there with the same level of talent and skills as these guys? Absolutely. But I don't know who they are. And in their sphere of influence, they very well could be considered masters of their craft.

What Makes a Master?

What do these individuals do differently than the rest of us?

The reality is that they aren't that different from us, in terms of skills and knowledge. What sets them apart is their relentless pursuit, their creativity and wisdom in the field of Computer Science. They pushed the industry forward in numerous ways throughout the years challenging the status quo and how we approach software. They experiment with new ideas, reform old ideas, and push current ideas to their extreme potentials. And to become a master, we must do the same.

For us to move towards mastery, we must first master (or become experts) the individual skills that are required as developers. Once we have achieved this, after years of study and practice, we must then do what they have done,

  • Always experiment with new ideas and concepts even if they aren't supposed to work on paper
  • Never accept "rules" as golden and question all ideas on merit
  • The study, both pragmatic teachings and theoretical ones (academia)
  • Challenge each other, building up comradery and a support backbone
  • Teach each other and learn what it takes to communicate effectively in private and in public
  • Never think of "impossibilities." Thinking something is impossible only leads to muted creativity
  • Build wisdom by practicing humility and utilizing intuition to make sound judgment calls

Now, I said "after years of study and practice" do the previous items. But I think that might not be right. We should start these now. What can it hurt? By making these your daily practices, you will continue to rise in your knowledge and wisdom, gaining influence along the way. We're not talking about being an "influencer," but a teacher; A person of respect.

Can we become Software Master?

I think the answer is now yes.

Conclusion and Sign-Off

I apologize if this post isn't what you thought it'd be. The premise of this write-up was to encourage you to never stop learning. Software is an infinite chasm of possibilities. You'll never know it all or everything there is to know about software. Typically, to master some skill, you must know everything there is to know about the topic. However, software is too large to do this. Instead, focus on your niche and be the best you can be there.

And never stop at the surface. When you use a new framework, understand what it is doing under the hood. You'll find that framework uses yet another framework. Learn that one too. Eventually you'll be down at the transistor level. Learn about NAND gates. But heck, how does a PNP / NPN transistor really work? Learn it.

The point is, the more you understand at the fundamental levels, the more chances of your ability to innovate in the field of computer science. You'll realize that assumptions are made in lower-level frameworks; Decisions that, if recalculated, may produce a unique result. It's this type of innovation that the masters perform.

Writing software is trivial. Writing great software is hard. Changing how software is written, that's mastery.

Let me know what you think! Please Follow Me here on Medium. It helps encourage me to continue writing!