I agree, they all seem to allow reusing multiple “classes” of behaviour. There are differences, though, and understanding these will probably aid your decision. Before providing a brief summary/highlight of each feature and examples of suitable usage, let’s just summarize on the conclusion of each. Conclusion / typical usage: @Delegate: Used to add all the … Read more
I don’t think the patterns per se are the problem, but rather the fact that developers can learn patterns and then overapply them, or apply them in ways that are wildly inappropriate. The use of patterns is something that experienced programmers just learn naturally. You’ve solved some problem X many times, you know what approach … Read more
But what is not clear to me is where the factory “layer” lies with a DDD architecture? Should the factory be calling directly into the repository to get its data or the service library? The factory should be the one-stop shop to construct domain objects. Any other part of the code that needs to do … Read more
I have found using dependency injection, to pass things in, to be the best style. It would indeed look something like you have: // App.js module.exports = function App() { }; // Database.js module.exports = function Database(configuration) { }; // Routes.js module.exports = function Routes(app, database) { }; // server.js: composition root var App = … Read more
Yes, repositories are generally used for queries only. Here is how I do it. The service layer manages the persistence. The controller layer knows of the service layer, but knows nothing of how the model objects are persisted nor where do they come from. For what the controller layer cares is asking the service layer … Read more
Having Commands gives you the benefits of the good old Command pattern: you can parameterize an object, e.g. a UI element, with a Command to perform you can store a Command and execute it later, e.g. in a queue or a transaction log you can track which Commands you executed, giving you a foundation for … Read more
Setting aside the argument of whether or not implementing the singleton pattern is a good idea, here’s a possible implementation: package singleton type single struct { O interface{}; } var instantiated *single = nil func New() *single { if instantiated == nil { instantiated = new(single); } return instantiated; } single and instantiated are private, … Read more
They usually go hand in and hand. In that using the composite pattern often leads to also using the decorator pattern. The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So … Read more
Let’s explain the strategy pattern the easy way: You have a class Car() with a method run(), so you use it this way in a pseudo language: mycar = new Car() mycar.run() Now, you may want to change the run() behavior on the fly, while the program is executing. For example, you might want to … Read more
A singleton pattern ensures that you always get back the same instance of whatever type you are retrieving, whereas the factory pattern generally gives you a different instance of each type. The purpose of the singleton is where you want all calls to go through the same instance. An example of this might be a … Read more