Module

Folders of content organised generally by the module that generated them

  2. "Expensive" Operations

  3. Acceptance criteria

  4. Adding like/dislike

  5. Additional info for your study case

  6. Agile and others

  7. Atomics

  8. awk

  9. BA Responsibilities

  10. Big-O

  11. Bitwise operators

  12. Business domains

  13. Business process model

  14. Cache Invalidation

  15. Caching

  16. Caching too much

  17. Capturing behaviour in tests

  18. cat

  19. Change management

  20. Classes and objects

  21. Clean Code Workshop

  22. Cloud

  23. Communicating effectively

  24. Comparing Implementations

  25. Comparing programming languages

  26. Computing Cache

  27. Containers

  28. Continuation styles

  29. CPU and memory

  30. Data modelling

  31. Databases

  32. Dataclasses

  33. Deadlock

  34. Debugging: Proposing and Discarding Hypotheses

  35. Demo

  36. Demo

  37. Design a solution

  38. Design mindset

  39. Design princples

  40. Discussion: Continuation styles

  41. Discussion: programming language concepts

  42. Do the Prep

  43. Docker

  44. Docker (language-specific)

  45. Docker Compose

  46. Entry Criteria

  47. Entry Tracks

  48. Enums

  49. Epics and features

  50. Expectations

  51. Extending: Adding Features the Right Way

  52. Extracting a middleware

  53. Extracting common functionality

  54. Fear and logic

  55. Finding things

  56. Fixing: Targeted Changes with Test Support

  57. FUN

  58. Functional architecture

  59. Generics

  60. Goals

  61. grep

  62. grep in pipelines

  63. head and tail

  64. Help

  65. HOCW

  66. How Computer really work? Chapter 1 & 2

  67. HTML-CSS

  68. Identifying patterns

  69. Induction

  70. Inheritance

  71. Intro Reading

  72. Introduction to Complexity

  73. jq

  74. JS1

  75. JS2

  76. JS3

  77. Limitations and trade-offs

  78. Logic

  79. ls

  80. Measure success

  81. Memoisation

  82. Memory consumption

  83. Memory Models

  84. Methods

  85. More cat

  86. Mutexes

  87. N+1 Query Problem

  88. Network as a bottleneck

  89. New case study

  90. Notes

  91. Optimising Locks

  92. Overcoming Blockers

  93. Pair programming

  94. Personas

  95. Piscine

  96. Pomodoro

  97. Portfolio

  98. Pre-computing

  99. Prep

  100. Prepare for the day

  101. Present your learnings

  102. Prioritisation

  103. Programming language concepts

  104. Project: Cache with Stats

  105. Re-entrance

  106. React

  107. Refining Purple Forest Bugs

  108. Requirements

  109. Review your BA tools

  110. sed

  111. Servers

  112. Sharing Our Blockers

  113. Shell pipelines

  114. Shell tools

  115. Single-variable Concurrency

  116. sort and uniq

  117. Specification

  118. Stakeholder mapping

  119. Stretch: Retrospective and Roadmap

  120. Study Case

  121. Submitting your steps

  122. SWOT Analysis

  123. System boundaries

  124. The Launch

  125. Threads and Concurrency

  126. tr

  127. Trade-offs

  128. Type checking with mypy

  129. Type-guided refactorings

  130. Understanding Legacy Code

  131. Use Cases

  132. User journey

  133. User research

  134. User research

  135. User research

  136. User stories

  137. Using existing middleware

  138. UX Design and Storyboarding

  139. Waterfall vs Agile

  140. wc

  141. WebSockets

  142. What is Legacy Code?

  143. Why we use types

  144. Worked example: Duplicate Encoder

  145. Workshop: Process Spelunking

  146. Wrap

  147. Wrap Party