📝 History of VSA

Author: Hona

.gitignore

@@ -1,2 +1,3 @@
 _site/
-node_modules/
+node_modules/
+.idea/

index.md

@@ -8,7 +8,7 @@ description: "The best place to learn about Vertical Slice Architecture (VSA). T
 
 Originating in 2018 by Jimmy Bogard, through [this blog post](https://www.jimmybogard.com/vertical-slice-architecture/) & this [NDC presentation](https://www.youtube.com/watch?v=SUiWfhAhgQw) Vertical Slice Architecture (VSA) has been making waves in the .NET community. It's a great way to have a highly cohesive codebase & deliver features quickly in an enterprise environment.
 
-The most dominant (and highly controvesial - at least online) architecture, Clean Architecture is the go-to for many organisations for it's great promises of maintainability and testability. However, it's not without it's drawbacks. But, more accurately, it's not the best choice for every project (i.e. the golden hammer).
+The most dominant (and highly controversial - at least online) architecture, Clean Architecture is the go-to for many organisations for its great promises of maintainability and testability. However, it's not without its drawbacks. But, more accurately, it's not the best choice for every project (i.e. the golden hammer).
 
 The most immediate difference between these two, is:
 
@@ -26,7 +26,7 @@ This is the best place to [learn](~/learn/overview.md) about Vertical Slice Arch
 
 There isn't much online in terms of VSA, so I'm hoping to change that (there are a lot of repetition of the same ideas). Both, by articulating the theory and by providing practical examples.
 
-The site is primarily a knowledge base for VSA, but the code examples are for .NET/C#, typically thinking about a Web API on the ASP.NET Core engine. This is done using a companion [VSA Template]() that I maintain. The template, importantly, should *not* be the starting point. It is a tool to bootstrap the theory learnt here.
+The site is primarily a knowledge base for VSA, but the code examples are for .NET/C#, typically thinking about a Web API on the ASP.NET Core engine. This is done using a companion [VSA Template](https://github.com/Hona/VerticalSliceArchitecture) that I maintain. The template, importantly, should *not* be the starting point. It is a tool to bootstrap the theory learnt here.
 
 ## I'm lost, help me!
 

learn/cookbook/history.md

@@ -1,3 +1,44 @@
-TODO: Introduce the history of VSA, as well as the history of architectures in general.
+<!-- 2018 is in the home page. But, there is stuff as early as 2015 called 'SOLID Architecture' which is basically his VSA stuff -->
 
-<!-- 2018 is in the home page. But, there is stuff as early as 2015 called 'SOLID Architecture' which is basically his VSA stuff -->
+# History
+
+Architecture is a certainty in software development. There have been many architectures over the years, and you can find a plethora of information on Google.
+
+The history of just Vertical Slice Architecture is a bit more recent. The term was coined by Jimmy Bogard in 2018. However, the ideas behind it have been around for a while. 
+
+## 2015
+
+In fact, [as early as 2015](https://vimeo.com/131633177), Jimmy was talking about SOLID Architecture which is essentially the same thing. It had a few key points (from his slides):
+
+> - SRP - One class per feature/concept
+> - OCP - Extend through cross-cutting concerns
+> - LSP - Just don't do inheritance
+> - ISP - Separating queries from commands
+> - DIP - Save for true external dependencies.
+
+The key points of the SOLID architecture were really applying the principals to achieve a highly cohesive codebase in regard to the Domain specific code (SRP, ISP). The Domain specific code was then extended (OCP) via cross-cutting concerns - like authentication, authorization & generic logging. 
+
+A lot of the outcomes from this talk to me, was allowing a simpler architecture for what matters most - the Domain. The most important thing in software, is that it works. The architecture that allows you to deliver features quickly, is the best architecture for you.
+
+## 2018
+
+Moving along a few years, in 2018, Jimmy wrote a blog post called [Vertical Slice Architecture](https://www.jimmybogard.com/vertical-slice-architecture/). This was the first time the term was used. It was then shortly followed up with [a presentation at NDC Sydney](https://www.youtube.com/watch?v=SUiWfhAhgQw) later that year.
+
+The key points of this evolution of the architecture were (from the presentation):
+
+- CQRS - e.g. HTTP GET is safe & idempotent, POST is Unsafe & not idempotent. Represent this two different concerns in different models/classes where this was just one.
+- Vertical Slicing makes it easy to modify code
+- Do not skip the refactor step in Red-Green-Refactor. (Common complaints about 'simple' architectures is due to this)
+- Push behaviour down (i.e. Focus on a rich domain & allow handlers to do the 'ugly' work, like data access)
+- Integration test handlers & unit test Domain
+
+## Where it was left
+
+At that point, Jimmy has set the world up with some pretty nice foundations.
+
+1. Logically split application reads & writes using CQRS.
+1. CQRS models are use cases. Application use cases should be sliced & tightly coupled within
+1. Refactor repeated logic into a rich Domain
+1. Refactor repeated domain-agnostic code into services, repositories
+1. Integration test use cases
+1. Unit test the Domain

learn/cookbook/philosophy.md

@@ -1 +1 @@
-TODO: This is where the rules of VSA go. This might become a subfolder with its own ToC.
+TODO: This is where the rules of VSA go - that are not specific. This might become a subfolder with its own ToC.

learn/cookbook/rules.md

@@ -0,0 +1 @@
+TODO: These are where specifics go

learn/overview.md

@@ -19,6 +19,6 @@ This will cover:
 
 ## Recipes
 
-> The recipes are strictly practical guides, that are hands on. Beyond trivial examples that exist online, more difficult questions are yet to be documented well. This is the place to go for those.
+> The recipes are strictly practical guides, that are hands-on. Beyond trivial examples that exist online, more difficult questions are yet to be documented well. This is the place to go for those.
 
 This is the more hands on side of the site. It goes over common patterns you might encounter while implementing VSA. It will also cover how to implement these patterns at a conceptual & practical level (using the [VSA Template](https://github.com/Hona/VerticalSliceArchitecture) using C# on .NET 8 & ASP.NET Core)