On this page
Software development has always had its conventions.
Some are grounded in decades of experience. Others emerge because particular technologies become successful, widely taught and eventually accepted as the normal way of doing things.
Conventions can be valuable. They make collaboration easier, reduce unnecessary decisions and provide shared methods for solving common problems.
But I don’t believe they should replace independent judgement.
Experience before convention
I began developing software long before many of today’s standard tools existed.
Like other developers working at the time, I established practices for organising source code, controlling changes, testing releases and recovering from mistakes.
Those methods developed through experience. Some were useful, others needed improvement, and many evolved as the nature of my work changed.
When newer tools became established, I evaluated them against what I already needed to accomplish.
Git is one example.
I know how to use it, and I can work with it when a project requires it.
But for my own development work, I prefer methods that have evolved from my earlier practices and suit the way I organise, verify and deliver software.
I don’t claim that my approach is better than Git.
Git was created to address particular challenges in large-scale distributed software development and remains an important solution for many teams.
My point is simpler: a widely adopted tool isn’t automatically the most appropriate choice for every person or project.
Ownership, control and responsibility
I place considerable value on maintaining direct control over my development environment, intellectual property and release process.
That doesn’t mean refusing to use software developed by other people. Quite the opposite.
I’ve spent years building sophisticated applications on established frameworks, including WordPress.
It does mean thinking carefully about the dependencies I introduce and the control I retain.
A locally operated development process is different from relying on a third-party hosting service. An open-source framework is different from a proprietary service on which a project becomes dependent.
These distinctions matter.
They affect how software can be maintained, transferred, recovered and developed over time.
My preference is to understand those dependencies rather than accept them by default.
The discipline behind an alternative approach
Working differently isn’t sufficient justification for an engineering decision.
A method still has to produce dependable results.
For me, that means being able to establish what has changed, inspect the consequences, test the outcome and recover when something goes wrong.
It also means recognising the limits of a method and adapting it when circumstances demand.
I have little interest in defending a practice merely because I’ve always used it.
I moved away from WordServer, a platform I had helped create, when continuing to maintain it no longer made sense.
That was a deliberate decision to adopt someone else’s technology.
Equally, I retain my own development methods where I find them appropriate.
Both decisions arise from the same principle: the requirements should determine the approach.
Thinking outside the box
I sometimes hear the phrase best practice used as though it settles an engineering discussion.
But a practice that works well in one setting may be unnecessary, inadequate or poorly suited to another.
Education and professional experience provide valuable foundations. We should understand established approaches and why they developed.
Then we need to be willing to question them.
That doesn’t mean assuming unconventional ideas are better.
They often aren’t.
It means retaining the freedom to investigate alternatives and evaluate them against practical evidence.
Sometimes a different approach produces a useful improvement.
Sometimes it reveals why the established method was sensible in the first place.
Either outcome can improve our understanding.
Engineering is not a declaration of allegiance
I don’t think the quality of a software engineer can be judged from a list of preferred tools.
What matters is the ability to understand requirements, make sound decisions, develop a workable solution and take responsibility for the results.
The tools support that work. They don’t define its purpose.
After more than thirty years of developing systems, I’ve become increasingly comfortable with a straightforward position:
Learn the established methods. Understand why they exist. Use them when they make sense. And remain willing to think independently when they don’t.
That isn’t a rejection of convention.
It’s an argument for retaining judgement.
Historical context
Research programme: From intention to implementation: human-directed AI-assisted engineering
Topic: Engineering practice
Explore further
Further reading is listed below.