Secure By Design
You don't need to be a security expert to write secure code. You can make your code more secure simply by following Domain Driven Design (DDD) practices.
Design Patterns
A collection of 16 posts
Domain-Driven Design Quickly
If you are likely for a primer to get started learning DDD, Domain Driven Design Quickly is a good starting point.
Can Your Code Be Too SOLID?
You can have too much of a good thing. Lots of code is hard to read because it uses too many unnecessary abstractions.
What is a plugin architecture?
I wrote a previous post about ppl plugins and it occurred to me that maybe not everyone knows what a plugin architecture is. So I decided to clarify a little bit in case it wasn’t clear. I’m going to talk in terms of classes inside packed project libraries
PPL Plugins
I wrote previously about Tom and I’s Gang of Four project where we are creating GOF Examples in LabVIEW. We’ve been getting distracted a little lately, but I have finally found some time to get back to it. I thought I would share with you what I have
Keystone Pattern
Reading the Continuous Delivery book recently has got me thinking a lot about ways to achieve continuous integration while still adding new features. The book suggested Branch By Abstraction as a way to avoid stepping on each other’s toes. It also mentioned the Keystone pattern.
The real problem the
Dynamic Unloading of Classes
In my previous post, I did a demo of the factory pattern. In it I showed how to dynamically load classes based on their path. One thing you may have noticed in that demo is that the classes stayed in memory even after the Test VI stopped running. If you
Gang Of Four Patterns in LabVIEW
I have written a bit about design patterns previously. Recently Tom McQuillan and I were talking about how it would be nice to have examples on how to implement the GOF design patterns in LabVIEW. To be fair, Elijah Kerry put together some great examples several years ago, but he
Book Review Dive into Design Patterns
Stefan Lemmens put me onto this book a few months in response to a review I wrote of the original GOF Design Patterns Book. He remarked that is was much more approachable and he was right. While I still find value in the original GOF book, I think this book
Test Doubles In Action
In the last post, I talked about Test Doubles and some various types that we can use and how to implement them. The next obvious question is how do we actually use them in our tests.
Dependency Injection
Understanding Test Doubles first requires understanding the concept of dependency injection. This
Intro to Test Doubles
It’s no secret that many Hollywood actors use stunt doubles. These are specialists that from the outside look and behave like the stars, but have unique talents. The actors do most of the heavy lifting in terms of acting, but for fight scenes, car chases, jumping off buildings, etc.
Humble Objects
Ego is the Enemy. Ego can cause us all kinds of problems in our personal and professional lives. When it comes to software, it is no different. Objects and VIs that have large egos create problems. One of the problems they cause is that they make it very hard for
A Business Case For Applying Design Patterns
This is my fourth article in a series on the Gang of Four book on Design Patterns. I thought four was an appropriate number of articles. Here are links to the first 3 articles:
1. Design Patterns – A Review
2. OOP Design Patterns in Actor Framework Part 1
3. OOP
OOP Design Patterns in Actor Framework Part 2
This is a continuation of my previous post on GOF Design Patterns in the Actor Framework. I found a lot of examples, so I decided to break it into 2 posts. You can access part 1 here and my review of the GOF Book here. Part 1 showed examples found
OOP Design Patterns in Actor Framework Part 1
Last week I wrote a review of the GOF Book on OOP Design Patterns. This week I would like to share some examples of these design patterns in action, so you can go look at them and see how they are implemented and used in LabVIEW. When I took Allen’
Design Patterns - A review
I recently finished reading “Design Patterns: Elements of Reusable Object-Oriented Software” by Erich Gamm, Richard Helm, Ralph Johnson, and John Vlissades. Due to its popularity, the length of the title, and the fact that it has 4 authors, it is affectionately known as the “Gang of Four” book or GOF
