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

  8. Atomics

  9. awk

  10. BA Responsibilities

  11. Big-O

  12. Bitwise operators

  13. Business domains

  14. Business process model

  15. Cache Invalidation

  16. Caching

  17. Caching too much

  18. Capturing behaviour in tests

  19. cat

  20. Change management

  21. Classes and objects

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

  31. Data modelling

  32. Databases

  33. Dataclasses

  34. Deadlock

  35. Debugging: Proposing and Discarding Hypotheses

  36. Demo

  37. Demo

  38. Design a solution

  39. Design mindset

  40. Design princples

  41. Discussion: Continuation styles

  42. Discussion: programming language concepts

  43. Distributed Tracing

  44. Distributed Tracing in Kafka

  45. Distributing with Kafka

  46. Do the Prep

  47. Docker

  48. Docker (language-specific)

  49. Docker Compose

  50. Entry Criteria

  51. Entry Tracks

  52. Enums

  53. Epics and features

  54. Expectations

  55. Extending: Adding Features the Right Way

  56. Extracting a middleware

  57. Extracting common functionality

  58. Fear and logic

  59. Finding things

  60. Fixing: Targeted Changes with Test Support

  61. FUN

  62. Functional architecture

  63. Generics

  64. Goals

  65. grep

  66. grep in pipelines

  67. Handling Errors

  68. head and tail

  69. Help

  70. HOCW

  71. How Computer really work? Chapter 1 & 2

  72. HTML-CSS

  73. Identifying patterns

  74. Induction

  75. Inheritance

  76. Intro Reading

  77. Introduction to Complexity

  78. jq

  79. JS1

  80. JS2

  81. JS3

  82. Kafka in a Nutshell

  83. Kafka Paper

  84. Limitations and trade-offs

  85. Logic

  86. ls

  87. Measure success

  88. Memoisation

  89. Memory consumption

  90. Memory Models

  91. Methods

  92. Monitoring

  93. More cat

  94. Multiple queues

  95. Mutexes

  96. N+1 Query Problem

  97. Network as a bottleneck

  98. New case study

  99. Notes

  100. Optimising Locks

  101. Overcoming Blockers

  102. Pair programming

  103. Personas

  104. Piscine

  105. Pomodoro

  106. Portfolio

  107. Practices to remember

  108. Pre-computing

  109. Prep

  110. Prepare for the day

  111. Present your learnings

  112. Prioritisation

  113. Programming language concepts

  114. Project: Cache with Stats

  115. Project: Kafka Cron Scheduler

  116. Queues

  117. Re-entrance

  118. React

  119. Refining Purple Forest Bugs

  120. Reproduction Steps

  121. Requirements

  122. Review your BA tools

  123. Running commands

  124. sed

  125. Servers

  126. Sharing Our Blockers

  127. Shell pipelines

  128. Shell tools

  129. Single-variable Concurrency

  130. sort and uniq

  131. Specification

  132. Stakeholder mapping

  133. Stretch: Retrospective and Roadmap

  134. Study Case

  135. Submitting your steps

  136. SWOT Analysis

  137. System boundaries

  138. The Launch

  139. Threads and Concurrency

  140. tr

  141. Trade-offs

  142. Type checking with mypy

  143. Type-guided refactorings

  144. Understanding Legacy Code

  145. Usability Workshop

  146. Usability Workshop Pre-reading

  147. Use Cases

  148. User journey

  149. User research

  150. User research

  151. User research

  152. User stories

  153. Using existing middleware

  154. Using Honeycomb

  155. UX Design and Storyboarding

  156. Waterfall vs Agile

  157. wc

  158. WebSockets

  159. What is Legacy Code?

  160. Why we use types

  161. Worked example: Duplicate Encoder

  162. Workshop: Process Spelunking

  163. Wrap

  164. Wrap Party