Categories
Resources Software Development

Domain Driven Design Resources

Domain Driven Design Learning Resources

Domain Driven Design and it’s related concepts can take some time to understand. Below are links to articles, books and videos I have found helpful.

Articles

Here is a free guide to Domain Driven Design written by microsoft.   This guide covers CQRS and Event Sourcing complete with an app that can be downloaded and inspected while reading the guide. This covers bounded contexts and suggestions for finding them and much more. This is an excellent free source.

Using Aggregates and Factories in Domain Driven Design.

Aggregates & Entities in Domain-Driven Design

A little more information about aggregates

Effective aggregate design part 3 vaughn vernon

Effective aggregate design series vaughn vernon.
An introduction to event storming: The easy way to achieve domain-driven design
Modelling Reactive Systems with Event Storming and Domain-Driven Design

Domain driven design isn’t always the best design choice for all systems. This article details the many reasons why.
Why I don’t do Domain Driven Design. 

Tactical domain driven design. More information on domain driven design.

Domain Driven Design Reference Definition and Pattern Summaries.

Domain Driven Design Quickly – a free eBook summing up DDD the Eric Evans book.

Video

Domain Driven Design the good parts Jimmy Bogard


Eric Evans — Domain Driven Design Tackling Complexity in the Heart of Software


The Art of Discovering Bounded Contexts by Nick Tune

Finding your domains bounded contexts is an iterative process. In this video Nick covers some of the ideas behind this iterative process of mapping out your domains bounded contexts.


Domain-Driven Design: Hidden Lessons from the Big Blue Book – Nick Tune

Nick tune is funny. This is a really good talk about DDD Domain driven Design.

Categories
Resources Web Development

Javascript resources

javascriptweekly – keep up to date on the latest javascript news

How to deal with dirty side effects in your pure functional JavaScript

async/await is just the do-notation of the Promise monad

Do we really need classes in JavaScript after all?

The cost of javascript. Javascript is often misused and abused or poor practices are used. This article covers some of the things you can do to lighten your apps javascript load and clean up your code a little.

Should You Use Classes in JavaScript?

A re-introduction to JavaScript (JS tutorial)  – because developers couldn’t be bothered with the hard task of learning actual Javascript syntax we had to pollute the syntax even more with Classes etc.

Function expressions explained

Arrow function expressions explained – examples and explanation

Mocking is a code smell – interesting article about how you can get https://krasimirtsonev.com/blog/article/javascript-managing-events-dispatch-listenout of control with testing and dependency injection. It is about javascript but applies to other languages.

Eradicating memory leaks in Javascript – A very good article for anyone to who creates Apps with Javascript.

Javascript managing events

Javascript let vs var vs const – a good article explaining the differences.

Categories
Resources Software Development

Programming resources

Dependency Inversion vs Dependency Injection vs Inversion of Control vs Programming to Interfaces

Dependency Injection is evil.  The downsides of Dependency injection.

You don’t need to know dependency injection. An article about dependency injection with Javascript

SOLID Design Principles Explained: Dependency Inversion Principle with Code Examples

Pros and cons of Dependency injection.

Semantic versioning explained – how to version your software

Useful software

Apache Archiva™: The Build Artifact Repository Manager

Apache Archiva™ is an extensible repository management software that helps taking care of your own personal or enterprise-wide build artifact repository. It is the perfect companion for build tools such as Maven, Continuum, and ANT.

Archiva offers several capabilities, amongst which remote repository proxying, security access management, build artifact storage, delivery, browsing, indexing and usage reporting, extensible scanning functionality… and many more! Get the latest updates, follow us on twitter @archiva.

 

Categories
Resources

Event sourcing and CQRS resources

Event Sourcing and CQRS resources

Articles

This page from the Lagom Documentation explains why Event sourcing is useful. Advantages of Event Sourcing

Exploring CQRS and Event Sourcing This link is from a Microsoft project and is an excellent resource about CQRS and Event Sourcing. It walks you through the entire decision process of breaking down an entire application domain with basic Domain Driven Design concepts. It is very thorough and a great read to help you understand what goes into CQRS, Event sourcing and breaking your domain into smaller more useable chunks.

CQRS increases consistency.  This article is another good short argument for why you should use CQRS.

CQRS Documents by Greg Young

CQRS Clarified by Udi Dahan

Message brokers vs Message buses These two sound the same but are different this article covers the minor details.

What do you mean by “Event-Driven”. This is an excellent article by Martin Fowler which covers Event driven systems in more detail.

Event Sourcing and CQRS with AKKA 2.6 video. This page has a video, but it also has some really useful links below the video which is why  I included it as a link.

How to use CQRS with Akka 2.6 video. This page has a video like the one above with useful links.
Using Akka and Scala for CQRS and Event Sourcing – great in depth article about Event sourcing

Books

Patterns, Principles and Practices of Domain-Driven Design by Scott Millett and Nick Tune This book covers Event Sourcing and CQRS as well as all of the other principles of Domain Driven Design. The nice thing about this book is it has code examples, the code is C#, but you don’t have to down load it to view it and basically follow along. The examples often come after long explanations of the concepts, if you have time or know C# you can download and try the example code, a nice extra if you ask me.  This is one that stays in a pile next to my desk.

Designing Event-Driven systems. This is a free ebook so what does it hurt to read it?

Distributed Data for Microservices — Event Sourcing vs. Change Data Capture

Videos

Greg Young – CQRS and Event Sourcing – Code on the Beach 2014

Greg tells some great stories that relate to why CQRS and Event Sourcing are useful and gives interesting insights into use cases. For many of us who have been doing the old fashioned CRUD architecture of storing and reading everything from a database, this video will make sense of why that was a bad way of doing things. After this video you will really want to dig into CQRS and Event Sourcing in depth.


CQRS and Event Sourcing with Lagom by Miel Donkers


An Introduction to CQRS and Event Sourcing Patterns – Mathew McLoughlin

In this video Mathew explains how an Event Sourced system that utilizes CQRS works. One thing covered is why having separate read and write data stores is a good idea and how it works in an abstracted way.


Event Sourcing You are doing it wrong by David Schmitz

I like this video this guy is funny. David quickly covers Microservices, event sourcing and other Domain Driven Design concepts, tying things together in a very entertaining animated and funny way. This is one of my favorite videos about event sourcing, it answers a lot of questions and makes many good points. This video is worth watching more than once.


Allard Buijze – Talk Session: The Inconveniences of Event Sourcing

This video has some good abstract information about events and event sourcing in microservices. It points out some of the issues with event sourcing and how to overcome them. Allard covers the types of Events, commands, events, queries and how they are used in an event driven system. The most interesting and for me useful part of this video is the part about GDPR and how to comply in an Event Sourced system at about the 38:00 mark.


Martin Kleppmann — Event Sourcing and Stream Processing at Scale


Udi Dahan – If (domain logic) then CQRS, or Saga?

Udi tells a story that builds up to CQRS and Sagas. He says in CQRS that Commands can’t be allowed to fail. At about 27:00 he explains what this means. At ~31:00 he talks about eventual consistency and how to deal with it in a system. At about 40:00 give them the Rick Sanchez slow  ramp. LOL He finishes up by talking about bounded contexts.

Categories
Software Development

AKKA resources

As I find useful resources to AKKA I will list them here.

Links

Akka Documentation. The documentation is a great place to start.

Slideshare Akka Microservices. This slide series shows the related DDD concepts and how they relate to AKKA and Scala.

Here is a link about why you shouldn’t create too many akka actor systems in your application.
Akka anti-patterns: too many actor systems

Reactive microservices with Scala and Akka by Vaughn Vernon.

Books

Learning Akka by Jason Goodwin. I like this book because it is small and to the point. At about 250 pages this book jumps right into AKKA, it doesn’t tell any stories and the examples are concise and to the point. This is also a great starting book for Java developers looking to get started with Akka because the author shows how to do everything with Java then with Scala.  What immediately grabs your attention as you are reading this book is… how much more code it takes to do everything with Java. <– And that is why I don’t Java anymore. Java is like writing a novel to describe a page. This book mostly covers the basics of AKKA it doesn’t go into depth about all of the AKKA features and abilities. This book is just a nice, clean, overall introduction to AKKA with Java and Scala.  If you are new to AKKA this should be your first book.

AKKA concurrency by Derek Wyatt.  This is an older book, however it is still relevant. This book is  kind of long at over 500 pages, but it digs into how AKKA actually works.  What is nice about this book is it starts with an example and follows through with iterative changes as the book proceeds. The example is of a plane and flight crew and how all of the parts ( actors ) of the plane and crew interact to make the plane work. This book is more advanced and in depth than Jason Goodwins book, but I feel it explains the reasons behind what you are doing with AKKA. I’d read this book after reading Goodwins book, as it digs a little deeper into things giving more info on how AKKA works.

Videos

Webinar Akka Anti-Patterns, Goodbye: Six Features of Akka 2.6

Categories
Resources

Scala resources

Scala links

Here are some Scala resources I have found helpful.  I’ll be adding to the list as time goes on. I have books I have not had time to read which I will list later, I’ll also list new resources as I find useful ones. This serves mostly as a collection of notes so that I can remember what I read and where I read it so I can find it again later.

The number one place to start learning Scala is the new Scala book   written by Alvin Alexander. Alvin does an excellent job of explaining Scala concepts.  The Scala tour should link to the related parts of that book.

Here is a link to the Scala Api, these are the classes that make up the language. This is the best place to get a peak under the hood of Scala and find all of the methods of a Class or a Traits signature. You will see there are links to the Library API, the Compiler API and the reflection API.

allaboutscala.com This is an excellent website with tons of tutorials and information about Scala.

Scala Glossary of Terms. Here are many of the terms you will encounter when using Scala or reading about it.

All about Dependency injection in Scala.

Here is more information about dependency injection in Scala.

Simple Dependency injection in Scala without special frameworks.

Functional programming approaches to dependency injection.

Here is another article about functional programming and dependency injection with links to more information.

More about dependency injection and Functional programming vs OOP. How to Trick OO Programmers into Loving Functional Programming

Scala is full of lots of magic, magic that can make it hard to learn because you see things done in so many ways in so many places with often little to no explanation . 4 Fun and Useful Things to Know about Scala’s apply() functions   So much of what you will read assumes you know Scala inside and out and upside down, like the Lagom documentation here where it states “As you can see, the sayHello method is implemented using the apply factory method on ServiceCall” Which you look and look and there is not an apply factory method to be seen anywhere, so you have to stop and do some google work to figure out what is going on. This little line of magic is what the documentation means ”

 ServiceCall { name =>
    Future.successful(s"Hello $name!")

It is assumed that you know that in Scala anonymous functions always contain a hidden apply method etc. like the bottom of the linked article mentions.  The main learning curve to Scala is all of the 10001+ things you have to remember about everything everywhere, my brain just does not like to memorize everything about everything, it likes to solve really hard problems.

 

New Dotty Scala 3 indentation link

Scala Books

Programming in Scala 3rd edition.  By Odersky, Spoon and Venners these are the authors of the programming language so this is one of the more in depth books of about 800+ pages and covers all parts of Scala.  This is a good book and basically a must have reference you will want to look back at from time to time. It has many small examples that can be run in the command line. You can also create scripts and call them from the command line, which is how I did the larger examples instead of typing in all of the code.  This is an older book but it is still 100% relevant in case you are wondering.

Programming in Scala 2nd edition Wampler & Payne. This is another good book that covers Scala slightly differently than the Programming in Scala by Odersky, Spoon and Venners.  This book covers Object Oriented programming in Scala as well as Functional programming. The book is almost 550 pages long, not too large or small. It also covers the type system fairly well. I like it’s discussion of implicits, these can be confusing if you come from other languages.  This is also an older book but it is still 100% relevant.  This is one of my more favorite books.

Scala Cookbook by Alvin Alexander. I feel this book is one of the Scala must haves, this book lives on my desk.  Alvin has an amazing ability to explain complex subjects in simple terms that every day developers can understand.  This book is almost 700 pages long, it is older too, from 2013 but it is also 100% relevant. This book is so wonderful because it shows hundreds of ways to do things in Scala. This is a wonderful book to have while learning and long after you have learned Scala. Many times while learning a new language you will ask yourself of others “how do you do this in this language”, this book has all of those types of answers.  This book shows how to do so much and is full of so much useful information, this is one of the must haves.

Functional Programming Simplified by Alvin Alexander. This is a wonderful book of 800+ pages that tells a story about the pieces of functional programming, breaking down the subject into over 100 small 1 to 5 page chapters. If you want to understand functional programming in Scala this is the best place to start. Even though the book is over 800 pages, the short chapters along with the authors unique ability to express complex ideas in simple terms made this programming book fun to read.  I found that the small chapters were perfect for when I only had a few minutes to read. I honestly wish more books were written in this fashion.

Functional and Reactive Domain Modeling by Debasish Ghosh. This is another good book about functional programming in Scala.  At under 300 pages it is concise and to the point.  This book cover Scalaz and almost makes you want to use it just from reading about it.  It is best to read this book after the Alvin Alexander functional programming book, this book is more advanced.  In this book the author covers why you would want to use a functional paradigm and makes a strong persuasive argument for it.  Overall I really liked this book and it is a good addition to any serious Scala programmers library.

Video

Scala best practices I wish someone’d told me about – Nicolas Rinaudo

I wish this video had been around when I first started learning Scala it answers a lot of the questions I had at first. This is one of the best videos about Scala, so much useful information here.
Nicolas gets right to it in this video

  1. Array Comparison ~2:00
  2. Type Annotation ~3:55
  3. Unicode operators ~5:30
  4. Enumerations ~7:20
  5. Sealed Traits ~8:45
  6. ADT Algebraic Data Types ~12:20
  7. Case Classes ~15:50
  8. Custom Extractors ~18:45
  9. Structural types ~20:55
  10. Exceptions ~24:05
  11. Errors ~29:50
  12. The return Keyword ~31:45
  13. Implicit conversions ~33:55
  14. Implicit resolution ~36:30
  15. String concatenation ~39:45


Scala: Beyond the basics with Christopher Batey

This is an excellent video, this will clarify quite a few things for new comers to Scala.

This video covers how to rely on the compile more and libraries less. At about 3:30 he hits on what I noticed. I have learned like 7 different languages and thought I would just learn Scala. Well Scala is so much different it is like learning to program all over again. With the OOP and the Functional capabilities along with no sort of suggested best way to do things, it makes the beginners head roll, especially when you then discover there are multiple ways to do things. Even after you learn Scala for a while you have more options and more things you can do, so you have to come up with your own rules and make sure you and your teams stick to them.

The first 11 minutes of the video discuss expression vs statement based programming. At 11 minutes Christopher starts talking about Function composition which is the main concept of this video. This video is an excellent introduction to what functional programing really is. Type Aliases covered at 12:00 mark, I googled for a while trying to figure this out when I saw it, I got very little luck. The shenanigans of learning Scala is what inspired this website. Traits are discussed at ~12:30. At about 15:00 Christopher talks about repositories using traits. Traits are used for many things in Scala.

At about 16:00 the talk about functional programming begins.

  1. ~18:00 Curried functions are explained
  2. ~20:00 Function Composition explained
  3. ~23:15 Currying and Partial function application
  4. ~25:00  Scala Class use cases
  5. ~26:30  Implicits
  6. ~28:15 Higher Kinded Types
  7. ~39:15 Implicits conversion
  8. ~45:30 He gets to how it is harder to learn Scala than other common languages. Scala is a really different kind of language. I like it most for it’s conciseness. But learning it requires learning many programming related concepts you don’t normally learn or think about. Scala requires that you and your team have MUCH MORE DISCIPLINE and you have to force yourself to stick to a paradigm or else you will get a mess.

An excellent book that covers the subject of Functional programming and function composition is Functional and Reactive Domain Modeling by Debasish Ghosh  The book is well written with clear language in less than 300 pages it is all about Functional Scala with code examples. The book covers many subjects, it is one of the books I keep in a stack next to my desk. Check the table of contents of Amazon.

Categories
Software Development

Modular Software design

Build it Modular!!!

Those are the words I will always remember.  About 5 years ago I was talking to a retired Engineer in South Florida about an idea I had for an app at the time. His response was “Build it modular!”.  At the time it was already too late I had built the app and launched it and watched it flounder and fail.  Those words haunted me and lead me to ultimately research modular software architecture in depth. I was determined to never again build a Monolithic Big ball of mud.

One of the main reasons the app failed was because every time I would fix a bug another would popup. I had built a monolithic Big ball of mud ,  It was the way I had learned to build programs in college and books etc.  I had even gone as far as creating UML ( unified modeling language ) diagrams and EER ( enhanced entity relation model ). The problem with those is you change your mind while coding, so you have to also change your UML and EER or it gets out of sync with your code and database.  It was thought to be helpful to have the UML and EER’s match the actual code and database as basic documentation of the system for lead engineers.  I now prefer agile modelling methods.

We don’t learn modular programming.

Many college degrees, online courses etc. don’t cover modular software design. Most of the focus is on programming and making things work. While learning to program, most of the code we learn from as examples is fairly small. Inevitably as developers at some point we start building side projects. These side projects, especially when we are just beginning, start out as simple ideas and slowly grow. Eventually these projects turn into “Big balls of mud” where the code is tightly coupled and nearly impossible to add to or change.

How to find the modules of your program?


One subject that any developer aspiring to reach the top should invest time in is Domain Driven Design (DDD) . Domain driven design sounds complicated at first with all kinds of buzzwords like “Value Objects” and “Bounded Contexts”, but it helps you break down large applications and create a language everyone from the business leaders to the developers can understand. This breaking down of the domain ( aka your project) into smaller pieces, naturally leads to a modular design, but it is how you wire it all together that makes the difference.

By using the concepts of DDD you can more easily discover your domains bounded contexts ( aka modules). This is not always easy and you won’t always get it right the first time, it is an iterative process. Within each bounded context ( module ) you have aggregates, these are interacted with by calling api methods that work with each other to perform the tasks of the module.  These modules are what we consider microservices when going the microservice route. Finding your aggregates can be sort of hard.  Here is a link to more information about aggregates. Here is another helpful link about aggregates

How do modules work?

Each module should have one and only one responsibility, it should perform one single function/operation. The login module shouldn’t contain logic to also register a new user for example. Each module should be responsible for and have 100% control over it’s data. This means that one module should not access the data of another module. You may have a user_authentication table for example that stores the users password and email. Your system should have a UserAuthentication module and the login module should use it.

How to communicate between modules?


Modules can communicate  via (application programming interface ) API interfaces. These interfaces simply consist of commands you can send to the module to perform tasks. Basically the API interface is a file, a list of functions, a class( depending on the language/framework or your style ) a main method, it is the router of the module routing requests ( calling code ). The API Interface allows you to contact the aggregates of modules to get work done.  If you have ever created a class with public methods then you have created an API. The public methods of that class are the Application programmers interface for that class.

In Domain Driven Design these API Interfaces are known as aggregate roots and the root is made up of aggregates. Aggregates do things, like the methods of an API do things.  These aggregate roots are how you interact with modules/microservices to complete tasks.

There are many ways to integrate your modules ( make them communicate, glue them together ) into a larger system.  There are message queues, RPC (remote procedure calls) REST  ( representational state transfer ),  actor frameworks and more. Which system you choose depends on the circumstances of your app.  The main thing is finding your bounded contexts within your domain and splitting your app into modules.

For more information about how microservices/modules can communicate see Chapter 11 of  Patterns, Principles and Practices of Domain-Driven Design by Scott Millett and Nick Tune   Another good source on how microservices can communicate is Chapter 4 of Building Microservices by Sam Newman.  In a future series of blog posts I will cover how to use AKKA/Lagom to build an example app and explain the concepts in detail.

What is the goal of modular software design?

The main goal is to not create a Big ball of mud monolith. The idea is to divide and conquer, to be able to chunk our larger monolith app into smaller more manageable pieces, that can be split among teams and developed autonomously then combined into one working system.  If we can properly find our bounded contexts and make those our modules, we can turn those modules into microservices. 

Modular is Microservices

Basically building modular is building microservices.  Microservices are hard, they are essentially a distributed system. With microservices you have to deal with many things like Service Discovery, Load Balancing and much more. With a monolith your system is tightly coupled and hard to scale. What is the happy medium? Surely someone has thought about all of this and figured it all out.

Over a series of posts I will cover how to find a domains bounded contexts and how to translate that into Scala and AKKA/Play/Lagom Framework code. The problem I’ve had most when learning all of these concepts is, how does all of this work together? How do I break the system down then write the code in Scala and have it all not fail later? In the series I will break down an entire Social Platform and describe the why I make the design decisions I do. I will show what structures in Scala relate to the concepts of Domain Driven Design.  Sometime next year I will complete the Social Platform and offer a free partially built Scala app that interacts with the Social Platforms API to demonstrate all of the concepts.

Related Resources

Reactive Microservices Architecture: Design Principles For Distributed Systems  This is an ebook that covers the concepts mentioned in this article.

Categories
Resources Web Development

Web Development resources

Media queries you should know about

Browser support for Javascript API’s – This is a very useful table to see what is supported at the moment

Link to ecmascript feature tables to look up what you can use in Javascript in current browsers.

Transaction patterns for web applications – interesting article with good information.

Must-Have Social Meta Tags for Twitter, Google, Facebook, & More 

opendyslexic Font for dyslexic people or anyone in general a good font.

andika nice clear fonts for clean looking text that is easy to read

What You Need to Know About Open Graph Meta Tags for Total Facebook and Twitter Mastery– Very good introduction to the topic, not a long read.

List of all mime types

Categories
Software Development

Software Development

I’ve been programming for over 10 years, my current favorite language is Scala, I also use Javascript a lot. Here is a list of my articles about programming and software development.