Preface, Primer, Table of Contents, Etc.

A little bit of order to organize the chaos.

---

Introduction

I began this blog in earnest as a retirement project in the fall of 2023. The blog’s home page lists the entries chronologically from newest to oldest. Blog entries are often part of a series focused upon a theme. The first blog entry of a series is usually an introduction to the series and acts as a landing page to the other blogs in the series. There are crossover reference links to other blog entries as well.

This meta-blog entry organizes the themes of my blog entries. NOTE: This page will be updated as new blog entries are added to existing themes and new themes are introduced.

Table of Contents

• AI Notebooks
• Software Engineering
  • Abstraction
  • Miscellaneous
• Design Patterns
  • Design Pattern Foundations
  • Essential Design Patterns
  • Composable Design Patterns
• Hexagonal Architecture AKA Ports and Adapters
• Automated Testing
• Large Language Models and Generative AI
• True Stories
• Miscellaneous
• Blog Statistics

AI Notebooks

I have created AI/Google Notebooks for several of my blog series. Each provides an AI interactive experience with some of my central themes. There are several artifacts including an AI generated two-host podcast formatted summary. You can also interact with the generated AI hosts to some degree.

NOTE: I think that a Google account may be required to access the AI/Google Notebooks.

AI/Google Notebooks:

• Abstraction
• Design Pattern Foundations
• Essential Design Patterns
• Composable Design Patterns
• Interpreter Design Pattern
• Hexagonal Architecture AKA Ports and Adapters
• Automated Testing
• Large Language Models and Generative AI

Software Engineering

A degree in Computer Science has been the initial exposure to software for many developers; however, Computer Science is not the same as Software Engineering.

Abstraction

Abstraction is a core software engineering concept, and it’s more challenging to describe abstraction concretely than I originally thought.

• What is Abstraction? - An introduction to Abstraction.
• Cohesion and Coupling - My first attempt to describe Cohesion and Coupling.
• Cohesion and Coupling - Take 2 - My second attempt to describe Cohesion and Coupling.
• What is Cohesive Construction? - How to configure cohesive abstractions consistently.
• Getting the Right Abstraction is Hard - How I adjusted the abstraction in a design I inherited.

See: Abstraction AI Agent

SE Miscellaneous

• Bumper Sticker Computer Science and Software Engineering - I think this is my favorite entry.
• My Design Process - Everyone has their own way to approach design problems. This entry describes mine.

Design Patterns

Design Patterns changed how I approach software. I feel that every Software Engineer should have some degree of competence and comfort with design patterns.

Design Pattern Foundations

Design Patterns are not technically challenging, but they do require a slight paradigm shift in thinking. These blog entries lay some foundations toward that shift in thinking.

• Are you a cook or a chef? - Are you following the recipe or creating something new?
• Rules of the Game - Do you know more than just the rules of the game? Do you know strategy and tactics to win the game?
• Problem Solvers - We solve problems, usually in the form of code.
• Design Patterns are Everywhere - Design Patterns are not limited to Software Engineering. They are ubiquitous in most domains.
• Toolbox - Design Patterns are tools in your toolbox. Like most tools, we have mastered them when we not only know when to use them, but when not to use them.
• Parts is Parts - Most Object-Oriented Design Patterns are different combinations of the same set of OO constructs.
• Design Pattern Principles - There are only two Design Pattern Principles. Understanding them will help in understanding the underlying structures that reappear in Design Patterns.

See: Design Pattern Foundations AI Agent

Essential Design Patterns

The Seven Essential Design Patterns are the design patterns that will be used repeatedly in designs. They are the hammer and screwdriver of a software developers design pattern toolbox.

• Command - Objectify a function so that it becomes a first-class citizen in an Object-Oriented paradigm.
• Strategy - A variant of Command with multiple implementations for an interface.
• Template Method - Similar to Strategy, except the interface is replaced with an abstract base class, which houses the implementation for common behavior that applies in all cases.
• Adapter - A translation helper class that allows other classes to interact indirectly when they cannot interact directly due to different protocols and/or method signatures.
• Façade - Similar to Adapter in concept, but rather than performing basic translation, it shields the client application of its dependency upon a particularly nasty or complex class or set of classes.
• Factory - Allows an application to acquire an object reference without knowing class type and without having to call a new() constructor directly.
• Dependency Injection - Removes all dependency resolution from an application by transfering that responsibility to another entity whose sole responsibility is to configure and resolve object references for the application.

See: Essential Design Patterns AI Agent

Composable Design Patterns

The Composable Design Patterns focus upon behavior emerging from the composition of objects and their interaction in a structured formation rather than implemented within an individual class.

• Proxy - Place administrative wrapper objects around objects often to help manage their complexity or resources.
• Decorator -Layer additional behaviors upon core features.
• Chain of Responsibility - Delegate a request through a linked chain of handlers until one of the handlers can complete the request.
• Composite - Configure behavior emerging from a group of snippet behavior objects organized in a tree structure.
• Specification – Allow a Client to select or filter objects with specific attribute property values as specified by the Client.
• Interpreter – Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language. This pattern will require several blog entries.

See: Composable Design Patterns AI Agent

Interpreter Design Pattern

The Interpreter required its own series.

Interpreter allows software developers to design and implement their own Domain-Specific Languages. Interpreter is not just the pinnacle of Composable Design Patterns, but I feel it shares the top spot of all design patterns along with the Visitor Design Pattern.

Interpreter is not a difficult pattern to design or implement, but it’s a difficult pattern comprehend. Interpreter required multiple blog entries to do it justice.

• Interpreter - Introduction and overview.
• Domain-Specific Languages - Domain-Specific Languages solve domain-specific problems.
• Programming Language Grammars - Grammars define the structure rules for natural and programming languages.
• Grammars to Design - The Interpreter Design emerges from the Grammar.
• Design to Implementation - Implementing the Interpreter Design Pattern based upon a Design.Implementing the Interpreter Design Pattern based upon a Design.
• Scanners and Parsers, Theory and Practice - The basics of Scanner and Parser theory and practice.
• Scanners and Parsers, Implementation: Rational Expression Implementation Example Completed - Implementing the Scanner and Parser for the Rational Expression Evaluator Use Case
• Interpreter Design Pattern – Production Example: My Experience Using Interpreter on a Work Project - My Experience Using Interpreter on a Work Project.

See: Interpreter Design Pattern AI Agent

Hexagonal Architecture AKA Ports and Adapters Design

The Hexagonal Architecture (AKA Ports and Adapters) is a design that all software developers should know. It showcases how different Essential Design Patterns can work as a cohesive design.

• Hexagonal Architecture Introduction - Introduces Hexagonal Architecture
• Hexagonal Architecture - Structure - This describes the structure of the Hexagonal Architecture design, and how it’s really a pattern or design patterns.
• Hexagonal Architecture - Why it works - This describes why I feel that the Hexagonal Architecture design works so well. It’s based upon dependency and knowledge management. I feel that dependency and knowledge management applies to all OO based designs, and not just within the context of Hexagonal Architecture.
• Hexagonal Architecture - How it compares and contrasts with Clean Architecture - The two designs are mostly the same, but there are some differences worth pointing out.
• Hexagonal Architecture - Adapter Flexibility - We have quite a bit of flexibility with this design in the Adapter layer.

See: Hexagonal Architecture AKA Ports and Adapters AI Agent

Automated Testing

I didn’t appreciate automated testing until late in my career. My automated testing series begins with my Conversion from automated testing non-believer to almost a zealot. The series grew larger than I imagined. I ended up writing a short book on the topic.

Here is the complete Automated Test series:

• The Conversion of a Unit Test Denier or … How I Learned to Stop Worrying and Love Unit Testing - This is a summary of my journey from avoidance to introduction to acceptance of automated testing.
• Attributes of Effective Unit Tests - Unit Test properties that make them more useful than not
• Basic Elements of Automated Unit Tests - Elevating automated tests to first-class citizen status
• Test Doubles - Emulate dependencies without depending upon dependencies
• Suril, the Semaphore and Me - When the theory became practice for me
• Test-Driven Development - Writing Tests Before the Implementation - I know it sounds completely backwards, but please give it some consideration
• Yuri, the Programming Assignment and Me - My evening introducing Test-Driven Development to a young Computer Science student
• Be On Your Best Behavior - Test-Driven Development - How to create tests; Behavior-Driven Development - What tests to create
• What is Behavior in Behavior-Driven Development - More details about the nature of behavior
• Testing Benefits - Spoiler Alert – It’s not really about testing the code
• Testing Concerns - Test concerns may be a result of previous bad test experiences; there are ways to accommodate them
• A House Divided Against Itself Will Not Stand - Resolving the conflict between My Design Process and Test-Driven Development blog entries
• Working Effectively with Legacy Code - How to leverage automated test techniques when working with Legacy Code
• How do you know if your test code is really testing your code? - How Mutation Testing can help test your test suite
• Approval Testing - A Test Strategy for those who are reluctant to try Test-Driven Development - A testint strategy that’s in the intersection of Unit Testing and Characterization Testing
• Mastering Time in Software Testing - Strategies for Temporal Behavior Verification - Become a Time Lord and control time in your tests
• Humble Objects - Designing Code You Don’t Hate Testing - A pattern to help test code that’s difficult to test
• Test Layers: From Unit to System - Building Confidence with the Right Tests at the Right Level - There’s more to testing than Unit Tests.
• Consumer-Driven Contract Testing - Giving the consumer exactly what they asked for - When the Consumer supplies the Test Specifications to its Provider.

See: Automated Testing AI Agent

Large Language Models and Generative AI

AI has become a major topic since late 2022 with the introduction of ChatGPT among others. I learn a bit more about how to use them almost daily.

See: Large Language Models and Generative AI AI Agent

LLM/GenAI Introduction

LLM/GenAI Introduction - Like it or not, the AI Genie is out of the bottle.

Prompt Engineering Patterns

Prompt Engineering Patterns are the key to getting the best results from Generative AI. These blogs present a few patterns I learned via online courses.

• Prompt Engineering Patterns 1
• Prompt Engineering Patterns 2

True Stories

The following blog entries feature a few True Stories, or maybe they should be called: True Confessions. I try to include personal experiences where I can in my blog entries. Sometimes story is the entire blog entry. Sometimes it’s just a part of the blog entry.

I keep my previous employers and others anonymous. If I do mention someone by name, I only use their first name, and I get their permission, or I use a pseudonym.

• What is UML and why you may want to care - When I realized, in an Aha! moment, that OMT, the predecessor of UML, is more than just a design tool. It’s a way to model the problem that based upon the domain elements and their relationships.
• It’s Your Move - When I realized that software engineering was more than just knowing the rules of a programming language.
• Getting the Right Abstraction is Hard - Where I had one of my first experiences of working with someone else’s code and realizing that it could be designed better.
• Façade Design Pattern - Where I encapsulated a really nasty API away from the rest of my codebase.
• Dependency Injection - Where tightly coupled code limited my team’s testing abilities.
• Hexagonal Architecture – Adapter Flexibility - Where adopting Hexagonal Architecture and an Adapter Dispatcher provided the flexibility we needed to solve a rather challenging design problem.
• Chain of Responsibility Design Pattern - Where a Chain of Responsibility design solved a problem of different configurations of Address Books.
• Interpreter Design Pattern – Production Example - Where I created a Domain-Specific Language, even when that was not my original intent.
• My Design Process - How I evolve my designs.
• The Conversion of a Unit Test Denier … or How I Learned to Stop Worrying and Love Unit Testing.
• Suril, the Semaphore and Me - How I learned the true meaning of Software Under Test.
• Yuri, the Programming Assignment and Me - When I indoctrinated a young mind with TDD.
• Losing Your Job Stinks - Where I describe my unemployment experience during a down market after the dot-com bubble burst in the early 2000s.
• Testing Concerns - Where I list the lessons I learned when I was on the QA team.
• Abstraction - Where I describe the conversation, I had with a mentee at my college alma mater, which inspired this blog.
• What Is Cohesive Abstraction? - Where I describe my experience with Safety Critial Code as well as provide A Cautionary Tale, which darn near cost me my job.
• A House Divided Against Itself Will Not Stand - Where I resolve the conflict between My Design Process and Test-Driven Development blog entries.

Miscellaneous

This is for blog entries that were one-offs, and weren’t part of series

• Job Loss - Software Engineering has been a great career for me, but it wasn’t without a few bumps in the road. I wrote this blog when others I knew in the industry were running into the same bumpy road in their careers.

Statistics

Year	Blogs	Words	Most Views	Comments
2021	1	1,278	What is UML and why you may want to care	First prototype blog about UML to set up the environment on GitHub.
2022	0	0	N/A	Still employed; did not start blogging yet.
2023	21	38,229	Hexagonal Architecture – An Introduction	Topics covered were Design Pattern Introduction, Essential Design Patterns and Hexagonal Architecture.
2024	35	109,944	Interpreter Design Pattern – Domain-Specific Languages	Topics covered were Composable Design Patterns, Interpreter Design Pattern, Automated Testing, LLMs/GenAIs and Abstraction.
Totals	57	149,451