I am a .NET developer by passion and by profession. I started playing with code in 1996, taking up C# and .NET ardently from 2005. I enjoy working on most aspects of software engineering, from algorithms to architectures, with a penchant for parallelism, including high-performance and high-scalability systems.
Douglas Williams is my online alias for any activity related to software development that I undertake on my own time. I use an alias in order to demarcate these contributions from my full-time employments, facilitating their release under permissive open-source licenses such as MIT.
You will frequently find me answering questions on Stack Overflow as Douglas, mostly under the C# and .NET tags. I maintain a GitHub account under Douglas-Williams, and publish articles to my blog on this website. You may reach me by email on firstname.lastname@example.org.
In the real world, I go by the name of Karl Fenech. I have a BSc IT (Hons) from the University of Malta, an MSc Computer Science from the University of Edinburgh, and over ten years of professional experience in .NET roles, mostly in senior and tech lead positions. If you are interested in my professional and academic history, you may refer to my extended curriculum vitae or my LinkedIn profile. Feel free to contact me on email@example.com.
This website also hosts some stand-alone pages:
- MIME Headers Decoder: An online decoder for RFC 2047, the Internet standard for representing non-ASCII text in MIME message headers.
- Maltese Diacritics: An online tool for automatically adding diacritics to letters from the Maltese alphabet, based on word lookups against a wordlist.
- Game of Codes 2014 Video Player: An HTML5 multithreaded video player for a custom video format, designed for participants of the 2014 ICTSA Programming Challenge.
Behind the name
The title of this website is inspired by the amalgamation of software design principles that may be sensibly drawn upon for guiding software development. In the course of its evolution as a discipline, software development has seen the inception and popularization of various paradigms and principles, which occasionally conflict with each other. For example, the benefit of compile-time type checking for strongly typed languages is sometimes sacrificed for the flexibility of dynamic languages. Similarly, tension can arise between DRY and LSP when deciding whether inheritance is the best tool for promoting code reuse.
By borrowing from competing principles, one may come up with adapted solutions
that serve as a better fit for a given problem.
For example, C#, traditionally a strongly typed language, introduced the
dynamic keyword in C# 4
to accommodate the subset of scenarios where dynamic typing is preferable,
such as COM APIs.
by introducing support for type annotations and class-based object-oriented programming,
improving its suitability for developing large-scale applications
with the confidence of compile-time type checking.
Classes have now even been incorporated in ECMAScript 6.
As another example, the .NET Framework Class Library disregarded the
“composition over inheritance” principle
for some of its class hierarchies, including
which are easier to extend as abstract base classes than they would have been to compose.
Unquestioning adherence to a given principle may lead to it getting fossilized as the one true dogma. Rather than fall into this trap, developers should strive to maintain an open mind and be amenable to picking the best combination of guiding principles for the task at hand from their repertoire – a mix of dogmas, so to speak.