About

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

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 douglas@dogmamix.com.

Karl

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 six 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 karl.fenech@gmail.com.

DogmaMix

This website serves as an avenue for my personal programming projects and experiments. Its main component is the blog, hosted on a rudimentary custom-build CMS. The CMS runs on ASP.NET MVC 5, MarkdownDeep, and the Javascript code prettifier.

This website also hosts some stand-alone pages:

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. Conversely, TypeScript was designed to extend JavaScript, a dynamic language, 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 will now even be incorporated in the upcoming ECMAScript 6. As another example, the .NET Framework Class Library disregarded the “composition over inheritance” principle for some of its class hierarchies, including Stream and TextReader, 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.