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. Practices to remember

  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. Reproduction Steps

  109. Requirements

  110. Review your BA tools

  111. sed

  112. Servers

  113. Sharing Our Blockers

  114. Shell pipelines

  115. Shell tools

  116. Single-variable Concurrency

  117. sort and uniq

  118. Specification

  119. Stakeholder mapping

  120. Stretch: Retrospective and Roadmap

  121. Study Case

  122. Submitting your steps

  123. SWOT Analysis

  124. System boundaries

  125. The Launch

  126. Threads and Concurrency

  127. tr

  128. Trade-offs

  129. Type checking with mypy

  130. Type-guided refactorings

  131. Understanding Legacy Code

  132. Use Cases

  133. User journey

  134. User research

  135. User research

  136. User research

  137. User stories

  138. Using existing middleware

  139. UX Design and Storyboarding

  140. Waterfall vs Agile

  141. wc

  142. WebSockets

  143. What is Legacy Code?

  144. Why we use types

  145. Worked example: Duplicate Encoder

  146. Workshop: Process Spelunking

  147. Wrap

  148. Wrap Party