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. Cloud

  22. Communicating effectively

  23. Comparing Implementations

  24. Comparing programming languages

  25. Computing Cache

  26. Containers

  27. Continuation styles

  28. CPU and memory

  29. Data modelling

  30. Databases

  31. Dataclasses

  32. Deadlock

  33. Debugging: Proposing and Discarding Hypotheses

  34. Demo

  35. Demo

  36. Design a solution

  37. Design mindset

  38. Design princples

  39. Discussion: Continuation styles

  40. Discussion: programming language concepts

  41. Do the Prep

  42. Docker

  43. Docker (language-specific)

  44. Docker Compose

  45. Entry Criteria

  46. Entry Tracks

  47. Enums

  48. Epics and features

  49. Expectations

  50. Extending: Adding Features the Right Way

  51. Extracting a middleware

  52. Extracting common functionality

  53. Fear and logic

  54. Finding things

  55. Fixing: Targeted Changes with Test Support

  56. FUN

  57. Functional architecture

  58. Generics

  59. Goals

  60. grep

  61. grep in pipelines

  62. head and tail

  63. Help

  64. HOCW

  65. How Computer really work? Chapter 1 & 2

  66. HTML-CSS

  67. Identifying patterns

  68. Induction

  69. Inheritance

  70. Intro Reading

  71. Introduction to Complexity

  72. jq

  73. JS1

  74. JS2

  75. JS3

  76. Limitations and trade-offs

  77. Logic

  78. ls

  79. Measure success

  80. Memoisation

  81. Memory consumption

  82. Memory Models

  83. Methods

  84. More cat

  85. Mutexes

  86. N+1 Query Problem

  87. Network as a bottleneck

  88. New case study

  89. Notes

  90. Optimising Locks

  91. Overcoming Blockers

  92. Pair programming

  93. Personas

  94. Piscine

  95. Pomodoro

  96. Portfolio

  97. Pre-computing

  98. Prep

  99. Prepare for the day

  100. Present your learnings

  101. Prioritisation

  102. Programming language concepts

  103. Project: Cache with Stats

  104. Re-entrance

  105. React

  106. Refining Purple Forest Bugs

  107. Requirements

  108. Review your BA tools

  109. sed

  110. Servers

  111. Sharing Our Blockers

  112. Shell pipelines

  113. Shell tools

  114. Single-variable Concurrency

  115. sort and uniq

  116. Specification

  117. Stakeholder mapping

  118. Stretch: Retrospective and Roadmap

  119. Study Case

  120. Submitting your steps

  121. SWOT Analysis

  122. System boundaries

  123. The Launch

  124. Threads and Concurrency

  125. tr

  126. Trade-offs

  127. Type checking with mypy

  128. Type-guided refactorings

  129. Understanding Legacy Code

  130. Use Cases

  131. User journey

  132. User research

  133. User research

  134. User research

  135. User stories

  136. Using existing middleware

  137. UX Design and Storyboarding

  138. Waterfall vs Agile

  139. wc

  140. WebSockets

  141. What is Legacy Code?

  142. Why we use types

  143. Worked example: Duplicate Encoder

  144. Workshop: Process Spelunking

  145. Wrap

  146. Wrap Party