Philosophy

Lessons learned from code, projects, and people

1. Structure First, Chaos Later

A project with a clear structure saves hours, sometimes days, of confusion later. Define your architecture, data flow, and naming conventions before writing your first line of logic.

2. Clarity Beats Cleverness

Code golf impresses nobody during maintenance. If future-you can't understand present-you, you've failed as a communicator. Clear, obvious, readable code is a gift to everyone who touches the system.

3. UAT Is Sacred

A well-set-up UAT environment is the difference between confidence and chaos. It should feel like production, behave like production, and expose issues before users ever see them.

4. Say Everything Out Loud

Never assume people "just know" what you mean. Stating the obvious prevents misunderstandings, reveals blind spots, and keeps teams aligned with reality rather than assumptions.

5. Ask for Help Early

Understanding is strange. It can take hours of struggle or a single sentence from the right person. Asking for help speeds up learning and avoids building the wrong thing beautifully.

6. Own Mistakes Immediately

Mistakes are fine. Cover-ups are catastrophic. A lie creates a false reality that everyone operates within, and software built on false assumptions breaks.

7. C# Best Practices I Stand By

  • Use meaningful names; skip meaningless abbreviations.
  • Prefer composition over inheritance when possible.
  • Keep methods short, focused, and single-responsibility.
  • Use async/await properly; don't block threads unnecessarily.
  • Write pure methods when you can; side effects create gremlins.
  • Encapsulate, encapsulate, encapsulate.
  • Dependency Injection isn't optional. It's clarity and testability.

8. SQL Principles That Avoid Disaster

  • Index what you search by; don't index blindly.
  • Write readable SQL with uppercase keywords and logical formatting.
  • Understand execution plans; they tell the truth.
  • Normalise until you have a reason not to.
  • Never trust user input; parameterise everything.
  • Batch large operations; don't lock tables unnecessarily.
  • Use transactions carefully as they're power tools.

9. A Final Philosophy

Code is a conversation with the future. The clearer you speak, the kinder you are to everyone who has to continue the story.