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

  77. Intro Reading

  78. Introduction to Complexity

  79. jq

  80. JS1

  81. JS2

  82. JS3

  83. Kafka in a Nutshell

  84. Kafka Paper

  85. Limitations and trade-offs

  86. Logic

  87. ls

  88. Measure success

  89. Memoisation

  90. Memory consumption

  91. Memory Models

  92. Methods

  93. Monitoring

  94. More cat

  95. Multiple queues

  96. Mutexes

  97. N+1 Query Problem

  98. Network as a bottleneck

  99. New case study

  100. Notes

  101. Optimising Locks

  102. Overcoming Blockers

  103. Pair programming

  104. Personas

  105. Piscine

  106. Pomodoro

  107. Portfolio

  108. Practices to remember

  109. Pre-computing

  110. Prep

  111. Prepare for the day

  112. Present your learnings

  113. Prioritisation

  114. Programming language concepts

  115. Project: Cache with Stats

  116. Project: Kafka Cron Scheduler

  117. Queues

  118. Re-entrance

  119. React

  120. Refining Purple Forest Bugs

  121. Reproduction Steps

  122. Requirements

  123. Review your BA tools

  124. Running commands

  125. sed

  126. Servers

  127. Sharing Our Blockers

  128. Shell pipelines

  129. Shell tools

  130. Single-variable Concurrency

  131. sort and uniq

  132. Specification

  133. Stakeholder mapping

  134. Stretch: Retrospective and Roadmap

  135. Study Case

  136. Submitting your steps

  137. SWOT Analysis

  138. System boundaries

  139. The Launch

  140. Threads and Concurrency

  141. tr

  142. Trade-offs

  143. Type checking with mypy

  144. Type-guided refactorings

  145. Understanding Legacy Code

  146. Usability Workshop

  147. Usability Workshop Pre-reading

  148. Use Cases

  149. User journey

  150. User research

  151. User research

  152. User research

  153. User stories

  154. Using existing middleware

  155. Using Honeycomb

  156. UX Design and Storyboarding

  157. Waterfall vs Agile

  158. wc

  159. WebSockets

  160. What is Legacy Code?

  161. Why we use types

  162. Worked example: Duplicate Encoder

  163. Workshop: Process Spelunking

  164. Wrap

  165. Wrap Party