Reorder monorepo workshop content to match video (#1199)

Author: mike-north

.github/workflows/ci-website.yml

@@ -52,8 +52,8 @@ jobs:
       - run: yarn
       - name: Build
         run: yarn build
-      # - name: Lint
-      #   run: yarn lint
+      - name: Lint
+        run: yarn lint
       - name: Test
         run: yarn test
       - name: Cypress

packages/website/content/blog/domain-modeling-with-ts/02-value-objects-and-entities/index.md

@@ -68,18 +68,18 @@ import { PeashootEntity } from './peashoot-entity'
 
 @Entity()
 export class Location extends PeashootEntity<'loc'> {
-	constructor() {
-		super('loc')
-	}
+ constructor() {
+  super('loc')
+ }
 
-	@Column('text')
-	name!: string
+ @Column('text')
+ name!: string
 
-	@Column('text')
-	region!: string
+ @Column('text')
+ region!: string
 
-	@Column('text')
-	country!: string
+ @Column('text')
+ country!: string
 ```
 
 the base class `PeashootEntity<'loc'>` takes care of the id field for us, and prefixes it with `loc_` so that they're easy to identify if we ever see them logged.
@@ -89,7 +89,7 @@ The `@Entity` decorator is really important here. This is what means these are p
 ## Our task
 
 Our app contains a calculator UI
-![](./img/calculator.png)
+![Calculator UI](./img/calculator.png)
 where a gardener can enter a location and temperature, and they need to be able to get an estimate of the _date_ when the weather will be _no colder_ than that temperature.
 
 Here's how the data flow works

packages/website/content/blog/domain-modeling-with-ts/03-ubiquitous-language/index.md

@@ -14,7 +14,7 @@ A key part of Domain-Driven Design is getting in the same room with Subject-Matt
 
 When your SMEs and the people who write the software that they'll use are speaking in different terms, it's very likely that something will be lost in the conversation. **You want your future user/stakeholder to be able to correct any misconceptions you may have** (or verify that you're on the right track) and they must be able to understand what you're saying in order to do that. **It's actually important that you don't _adapt_ between different languages -- it's the actual application of the shared language that promotes strong alignment.**
 
-#### Tips
+### Tips
 
 - Clarify and confirm terminology to ensure shared meanings.
 - Use visual tools to make abstract concepts tangible.
@@ -24,7 +24,7 @@ When your SMEs and the people who write the software that they'll use are speaki
 
 Don't immediately jump in to suggest solutions too early, or your user might say "sure, build that" before a shared understanding is discussed.
 
-#### Tips
+### Tips <!-- markdownlint-disable-line MD024 -->
 
 - Focus on business problems before proposing solutions.
 - Ask open-ended questions to understand motivations, not just surface details.
@@ -36,7 +36,7 @@ Don't immediately jump in to suggest solutions too early, or your user might say
 
 As you build, you're going to run into more questions. You'll demonstrate what you've built and how you ended up organizing things, and it's important that you confirm with your user that you're on the right track. Keep pursuing a distillation of the _core domain_ -- the part of the software that's at the heart of its reason for existence
 
-#### Tips
+### Tips <!-- markdownlint-disable-line MD024 -->
 
 - Summarize and reflect concepts back to experts for verification.
 - Identify and focus on critical business domain aspects that create core value.

packages/website/content/blog/domain-modeling-with-ts/04-seed-collection-discussion/index.md

@@ -188,7 +188,7 @@ If you have access to an LLM, here's a prompt to seed a conversation with
 <pre>
 You are a "domain expert" (in the Domain Driven Design sense) in planning, caring for and harvesting vegetable gardens planted in raised garden beds, to be used in a domain driven design workshop for software engineers to practice conversing with a "domain expert". You are to engage in a collaborative conversation around common language to be used in this problem space, and the core complexity associated with your gardening challenges. You are looking for the person engaging with you in conversation to help you solve some of your challenges in a piece of gardening software, so err on the side of asking for help rather than offering help.
 
-You have a seed collection of hundreds of packets of vegetable seeds, and your garden has about 600sqft of plantable area. Your garden is irrigated with a 12 zone Rachio irrigation controller, with independent zones for raised bed areas vs. ground-level areas (e.g. for trees, shrubs). Your garden is in Kirkland, WA USA. You don't know a thing about building software, and are familiar with the concept of a database, the concept of custom logic in software (e.g. spreadsheet formulas, simple "if this, then that" rules), etc... 
+You have a seed collection of hundreds of packets of vegetable seeds, and your garden has about 600sqft of plantable area. Your garden is irrigated with a 12 zone Rachio irrigation controller, with independent zones for raised bed areas vs. ground-level areas (e.g. for trees, shrubs). Your garden is in Kirkland, WA USA. You don't know a thing about building software, and are familiar with the concept of a database, the concept of custom logic in software (e.g. spreadsheet formulas, simple "if this, then that" rules), etc...
 
 To get plants started, you have ~14 cheap hydroponic devices (generic versions of an AeroGarden) on Amazon with an 18-pod capacity, and set them up on folding tables in a spare room in your house. You keep seedlings in the hydroponic setup long enough that they can benefit from the accelerated hydroponic growth, but not so long that it's difficult to extract the planting sponges (which you buy on Temu) from the plastic baskets without damaging the plant's roots. You like the "square foot garden" concept because it simplifies spacing requirements and makes it easy to plan raised beds. Your outdoor raised beds are placed in different locations on your property, some of which get "full sun", and others that are in partially shady spots. The beds vary in shape -- 6 are 14x2 feet, 14 are 8x2, 5 are 3x6, 1 is 4x4, 3 are 4x6, one is 2x3, 3 are 2x2
 
@@ -212,8 +212,7 @@ You have several fruit trees in your garden
 - 4x Ranier Cherry
 - 1x Paradise Apple
 
-
-And a few perennials 
+And a few perennials
 - Anna Hardy Kiwi
 - Thornless red raspberry
 - Several highbush blueberry plants

packages/website/content/blog/domain-modeling-with-ts/05-seed-collection-implementation/index.md

@@ -6,9 +6,9 @@ description: "Let's attempt our first discussion with a domain expert and an AI
 course: domain-modeling-with-ts
 ---
 
-## Let's implement it!
+## Let's implement it
 
-![](./img/seed-collection-ui.png)
+![seed collection](./img/seed-collection-ui.png)
 
 Once you've decided on your domain model, implement it in the workshop project!
 

packages/website/content/blog/domain-modeling-with-ts/06-bounded-contexts/index.md

@@ -14,7 +14,7 @@ We have a need for this in our workshop project! There's a fancy UI for dragging
 ![Drag and drop raised bed planning UI](./img/dnd-ui.png)
 
 We have an existing domain model that lives in our UI
-![](./img/ui-bounded-context.png)
+![bounded context diagram](./img/ui-bounded-context.png)
 
 This has nothing to do with gardening! Our UI entirely deals in a world of
 

packages/website/content/blog/domain-modeling-with-ts/07-raised-beds-domain-discussion/index.md

@@ -9,9 +9,7 @@ course: domain-modeling-with-ts
 Time to dig into our garden bed domain model. Let's start with the following user needs to anchor on to
 
 > I need to be able to plan out where I want things to go in my raised beds, well in advance of the plants actually going into the ground
-
 > I'd like to embrace the square-foot garden concept
-
 > I'd like to ensure I put my plants in the place that's best for them
 
 These are intentionally vague statements. Dometimes your domain experts will use terminology that you don't understand, or that's insufficiently precise to build software around. Part of your job is to ask clarifying questions and help drive a discussion that leads toward deeper understanding and **refinement of knowledge**.

packages/website/content/blog/domain-modeling-with-ts/08-raised-beds-domain-implementation/index.md

@@ -6,7 +6,7 @@ description: "We'll implement our raised bed entities, value objects and relatio
 course: domain-modeling-with-ts
 ---
 
-Now let's implement our domain model! Our goal is to get some sort of diagram showing up on the http://localhost:5173/garden page.
+Now let's implement our domain model! Our goal is to get some sort of diagram showing up on the <http://localhost:5173/garden> page.
 
 - The plants must show up as the appropriate size (e.g. tomatoes must be 2x2 tiles)
 - The plant tiles (`ItemPlacement` in the UI domain model) should have a working icon (it's ok if a few don't work). Icons are in `packages/client/public/plant-icons/*` and if you just provide an `Item.iconPath` that's set to a filename in that folder, it should show up on the tile

packages/website/content/blog/monorepos-v2/01-intro/index.md

@@ -9,21 +9,23 @@ order: 1
 
 ![monorepos-v2 logo](./img/monorepos-v2-256.png)
 
-
 A monorepo is the concept of **many software packages being stored in the same SCM repository**. There are several key benfits
+
 * Monorepo dependencies are _always on latest_.
 * Atomic multi-package code changes
 * Simpler external dependency
 * Upstream changes validated against downstream test suites
 
 In this course, we'll refactor a small client/server app into monorepo. By the end, we'll have
+
 * Monorepo dependencies automatically linked
 * Parallized dependency-aware task execution for build, linting and testing
 * Commands for CI that run tests on _only the code affected by the change_
-* Support for _some_ packages in the monorepo being more coupled with each other than others, by design (e.g. using _private_ functionality) 
+* Support for _some_ packages in the monorepo being more coupled with each other than others, by design (e.g. using _private_ functionality)
 * Automatic code documentation
 
 We're going to be using some of the latest and greatest tooling, including
+
 * `pnpm`
 * `lerna` v7
 * `nx` for distributed caching
@@ -35,33 +37,41 @@ We're going to be using some of the latest and greatest tooling, including
 * `syncpack` (or an equivalent `nx` tool) to rally your monorepo around a single version of each dependency
 * ...and more!!!
 
-
 ## Project setup
 
-### 1. Make sure you have [`pnpm`](https://pnpm.io/) installed.
+### 1. Make sure you have [`pnpm`](https://pnpm.io/) installed
+
 If you don't using `volta` (get it at [https://volta.sh](https://volta.sh)) is a great way to obtain it.
 
-First, install volta 
+First, install volta
+
 ```sh
 curl https://get.volta.sh | bash
 ```
+
 You may need to close and reopen your terminal before your can verify that your environment has volta installed
+
 ```sh
 volta --version
 > 2.0.2 
 ```
+
 Then you can run
+
 ```sh
 volta install pnpm
 ```
+
 And you should be good to go. Alternatively you can follow [`pnpm`'s direct installation instructions](https://pnpm.io/installation)
 
 ### 2. Check out the git repo
+
 ```sh
 git clone git@github.com:mike-north/ts-monorepos-v2
 ```
 
 ### 3. Install dependencies
+
 ```sh
 cd ts-monorepos-v2  # Enter the project folder
 pnpm install        # Install dependencies
@@ -80,8 +90,8 @@ pnpm run test       # Test the project
 ```sh
 pnpm run dev
 ```
-* You should be able to go to http://localhost:3000/api/seeds in a browser and see some JSON
-* You should be able to go to http://localhost:5173/ and see a UI that looks like this
 
+* You should be able to go to <http://localhost:3000/api/seeds> in a browser and see some JSON
+* You should be able to go to <http://localhost:5173/> and see a UI that looks like this
 
-![app screenshot](./img/app-ui-screenshot-512.png)
+![app screenshot](./img/app-ui-screenshot-512.png)

packages/website/content/blog/monorepos-v2/02-project-tour/index.md

@@ -10,18 +10,23 @@ order: 2
 This project, currently a small monolith, consists of a couple of things. We'll end up turning each of these areas into a dedicated package by the end of the course
 
 ### Model(s)
+
 A TypeScript interface describing the file data (search for `seed-packet-model.ts`)
 
 ### Server
+
 #### Data
+
 A data file with some info about seed packets (search for `seeds.yml`)
+
 #### API
-A server that loads the data file and starts an express server to serve the data as JSON (entry point is `src/server/main.ts`). **This API is on [`http://localhost:3000/api/seeds`](http://localhost:3000/api/seeds)**
 
+A server that loads the data file and starts an express server to serve the data as JSON (entry point is `src/server/main.ts`). **This API is on [`http://localhost:3000/api/seeds`](http://localhost:3000/api/seeds)**
 
 ### UI
+
 A Svelte 5 UI for fetching the data from the server and rendering some components in the browser (search for `App.svelte` as the entry point). **This UI is served on [`http://localhost:5173/`](http://localhost:5173/)**
 
 ### Utilities
-Some utility functions in `src/utils`
 
+Some utility functions in `src/utils`