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. Clean Code Workshop

  22. Cloud

  23. Communicating effectively

  24. Comparing Implementations

  25. Comparing programming languages

  26. Computing Cache

  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. Entry Criteria

  43. Entry Tracks

  44. Enums

  45. Epics and features

  46. Expectations

  47. Extending: Adding Features the Right Way

  48. Extracting a middleware

  49. Extracting common functionality

  50. Fear and logic

  51. Finding things

  52. Fixing: Targeted Changes with Test Support

  53. FUN

  54. Functional architecture

  55. Generics

  56. Goals

  57. grep

  58. grep in pipelines

  59. head and tail

  60. Help

  61. HOCW

  62. How Computer really work? Chapter 1 & 2

  63. HTML-CSS

  64. Identifying patterns

  65. Induction

  66. Inheritance

  67. Intro Reading

  68. Introduction to Complexity

  69. jq

  70. JS1

  71. JS2

  72. JS3

  73. Limitations and trade-offs

  74. Logic

  75. ls

  76. Measure success

  77. Memoisation

  78. Memory consumption

  79. Memory Models

  80. Methods

  81. More cat

  82. Mutexes

  83. N+1 Query Problem

  84. Network as a bottleneck

  85. New case study

  86. Notes

  87. Optimising Locks

  88. Overcoming Blockers

  89. Pair programming

  90. Personas

  91. Piscine

  92. Pomodoro

  93. Portfolio

  94. Pre-computing

  95. Prep

  96. Prepare for the day

  97. Present your learnings

  98. Prioritisation

  99. Programming language concepts

  100. Project: Cache with Stats

  101. Re-entrance

  102. React

  103. Refining Purple Forest Bugs

  104. Requirements

  105. Review your BA tools

  106. sed

  107. Servers

  108. Sharing Our Blockers

  109. Shell pipelines

  110. Shell tools

  111. Single-variable Concurrency

  112. sort and uniq

  113. Specification

  114. Stakeholder mapping

  115. Stretch: Retrospective and Roadmap

  116. Study Case

  117. Submitting your steps

  118. SWOT Analysis

  119. System boundaries

  120. The Launch

  121. Threads and Concurrency

  122. tr

  123. Trade-offs

  124. Type checking with mypy

  125. Type-guided refactorings

  126. Understanding Legacy Code

  127. Use Cases

  128. User journey

  129. User research

  130. User research

  131. User research

  132. User stories

  133. Using existing middleware

  134. UX Design and Storyboarding

  135. Waterfall vs Agile

  136. wc

  137. WebSockets

  138. What is Legacy Code?

  139. Why we use types

  140. Worked example: Duplicate Encoder

  141. Workshop: Process Spelunking

  142. Wrap

  143. Wrap Party