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. 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 programming languages

  25. Continuation styles

  26. CPU and memory

  27. Cron

  28. Data modelling

  29. Databases

  30. Dataclasses

  31. Debugging: Proposing and Discarding Hypotheses

  32. Demo

  33. Demo

  34. Design a solution

  35. Design mindset

  36. Design princples

  37. Discussion: Continuation styles

  38. Discussion: programming language concepts

  39. Distributed Tracing

  40. Distributed Tracing in Kafka

  41. Distributing with Kafka

  42. Do the Prep

  43. Entry Criteria

  44. Entry Tracks

  45. Enums

  46. Epics and features

  47. Expectations

  48. Extending: Adding Features the Right Way

  49. Extracting a middleware

  50. Extracting common functionality

  51. Fear and logic

  52. Finding things

  53. Fixing: Targeted Changes with Test Support

  54. FUN

  55. Functional architecture

  56. Generics

  57. Goals

  58. grep

  59. grep in pipelines

  60. Handling Errors

  61. head and tail

  62. Help

  63. HOCW

  64. How Computer really work? Chapter 1 & 2

  65. HTML-CSS

  66. Identifying patterns

  67. Induction

  68. Inheritance

  69. Introduction to Complexity

  70. jq

  71. JS1

  72. JS2

  73. JS3

  74. Kafka in a Nutshell

  75. Kafka Paper

  76. Limitations and trade-offs

  77. Logic

  78. ls

  79. Measure success

  80. Memoisation

  81. Memory consumption

  82. Methods

  83. Monitoring

  84. More cat

  85. Multiple queues

  86. N+1 Query Problem

  87. Network as a bottleneck

  88. New case study

  89. Notes

  90. Overcoming Blockers

  91. Pair programming

  92. Personas

  93. Piscine

  94. Pomodoro

  95. Portfolio

  96. Pre-computing

  97. Prep

  98. Prepare for the day

  99. Present your learnings

  100. Prioritisation

  101. Programming language concepts

  102. Project: Kafka Cron Scheduler

  103. Queues

  104. React

  105. Refining Purple Forest Bugs

  106. Requirements

  107. Review your BA tools

  108. Running commands

  109. sed

  110. Servers

  111. Sharing Our Blockers

  112. Shell pipelines

  113. Shell tools

  114. sort and uniq

  115. Specification

  116. Stakeholder mapping

  117. Stretch: Retrospective and Roadmap

  118. Study Case

  119. Submitting your steps

  120. SWOT Analysis

  121. System boundaries

  122. The Launch

  123. tr

  124. Trade-offs

  125. Type checking with mypy

  126. Type-guided refactorings

  127. Understanding Legacy Code

  128. Use Cases

  129. User journey

  130. User research

  131. User research

  132. User research

  133. User stories

  134. Using existing middleware

  135. Using Honeycomb

  136. UX Design and Storyboarding

  137. Waterfall vs Agile

  138. wc

  139. WebSockets

  140. What is Legacy Code?

  141. Why we use types

  142. Worked example: Duplicate Encoder

  143. Workshop: Process Spelunking

  144. Wrap

  145. Wrap Party