A Self-Taught Programmer's Perspective on Code Trustworthiness

Is code developed by a self-taught programmer trustworthy? The answer, in my experience, is an unequivocal yes. This is not to say that all self-taught programmers are equally capable, but it is to highlight that trustworthiness is not a function of formal education or self-taught status alone.

Design Techniques and Code Quality

When it comes to writing good programs, the process starts with good design techniques. Good design means leaving nothing to chance. A comprehensive understanding of how applications handle exceptions, perform exhaustive testing for issues like buffer overflows, memory limitations, garbage collection, and illegal data types is crucial. These are not luxury practices; they are essential for ensuring robust, maintainable code.

Some people may undervalue the role of compilers in these processes, but it's important to remember that compilers can introduce additional layers of complexity. For instance, they may not flag all potential issues, and leaving everything to them can introduce unnecessary risks. Therefore, thorough testing and debugging are paramount. This is a process that diligent and self-taught programmers often excel at because they have the hands-on experience necessary to spot and rectify these issues.

The Role of Experience and Practical Knowledge

Trust in code is not just about the process but also about the experience and practical knowledge of the developer. Self-taught programmers often gain this through practical experience rather than formal education. The best programmers are often self-taught because they have the passion and obsessive attention to detail required to excel in their craft.

The field of programming is complex and ever-evolving, with new technologies and methodologies emerging regularly. Self-taught individuals must continuously learn and adapt, often through trial and error. This practical experience can be just as valuable, if not more so, than classroom knowledge. In fact, practical experience can sometimes make up for a lack of formal theoretical knowledge.

Case Study: My Journey and Skills

My journey as a self-taught programmer began when I was a teenager. I started working before graduating high school and became a full-time software developer a couple of years after graduating. My formal education in software development is limited, consisting of just a few courses and classes. However, my practical experience and self-study have provided me with a wealth of knowledge and skills.

By the time I was 16 and working my first job, I had already written thousands of lines of working code. I had learned two major programming languages, BASIC and PL/I. I had implemented a double-linked list from an example of a single-linked list, implemented 3-D transforms, and created a dual 2-D display to simulate a 3-D scan for a starship combat game on an 824 screen.

This extensive experience far exceeds the typical output of many college graduates, especially for a single project. Moreover, I had gained a taste of product lifecycle, maintenance, and feature enhancement, all of which are crucial for long-term development. The skills I acquired have been invaluable in my 40-year career, allowing me to quickly learn and apply new technologies and methodologies as they emerged.

Conclusion

Trusting code developed by a self-taught programmer should not be based on their educational background alone. Trust is earned through thorough testing, rigorous debugging, and practical experience. Self-taught programmers often possess a deep understanding of their craft and can provide code that is just as trustworthy, if not more so, than that developed by formally educated developers.

My experience teaches me that skill and dedication are what truly matter. So, whether a programmer is self-taught or formally trained, their code should be judged based on its quality and reliability, not on where or how they learned to code.