Elixir Conf EU - Lessons Learned from Elixir Learning Paths

After 3 years of following the Elixir journey, I have found happy and unhappy paths that I would like to structure and share in this talk.

I had the privilege of being part of the Plataformatec team and be immersed directly or indirectly in the Elixir world from 2018 to 2020. We had recurrent study groups, tech talks, and chapter meetings to learn, review, and discuss the technical and non-technical aspects of the software engineering path.

Now, after so many unexpected changes and working for a new company, I see how important was Plataformatec in my professional life; how many lessons I learned as a consultant and as a software engineer; and how my study habits had to be adapted to this remote world.

In this talk, I will summarize this experience and present my current project to learn and teach Elixir.

Transcript

1. Elixir LEARNING PATHS Lessons Learned
2. Software Engineer/Developer (since 2008) B.Sc. in Computer Engineering M.Sc. in Computer Science Software Engineer at The RealReal ELAINE NAOMI WATANABE
3. São Paulo / Brazil (GMT -3:00)
5. RUA DO PARAÍSO, 595, 4TH FLOOR
9. LEARNING PATHS
11. LEARNING PATH An organized set of learning activities that allows building knowledge progressively https://en.wikipedia.org/wiki/Learning_pathway
12. exercism.org/tracks/elixir/concepts
13. #1 - LEARNING PATH VS SELF-STUDY
14. Measured Time to Proficiency Definition of Proficiency Documented Content and Activities Evaluation and Revision LEARNING PATH
15. Learning about a subject Outside the classroom Without direct supervision Self-paced Learning SELF-STUDY / SELF-LEARNING
16. SELF-STUDY CHALLENGES What to learn? Which resources can I use?
17. SELF-STUDY CHALLENGES What to learn? Which resources can I use? Where to find the resources, how accessible they are? Why learn a specific topic? When should I start? Who can support my learning?
18. elixir-lang.org
19. elixirschool.com
21. exercism.org
22. exercism.io
23. exercism.org/tracks/elixir/concepts
24. ...
25. SELF-STUDY CHALLENGES What to learn? Which resources can I use? Where to find the resources, how accessible they are? Why learn a specific topic? When should I start? Who can support my learning?
26. How to learn? How to improve the learning process?
28. Focus Self-Discipline Motivation Study plan Time and energy management How to study / read effectively
29. I thought that just reading a book would be enough to learn basic Elixir concepts
31. at the same time I was reading other technical books
33. At the end of that book club, I forgot everything I learned about Elixir
34. #2 - SPACED LEARNING
35. The learning happens when you sleep
36. But, after two days, you will remember of 25% of what you have learned The Forgetting Curve
37. The more you repeatedly study something, the stronger the memory of it is Storage Strength
38. However, only repetition is not enough
39. We need to strengthen the retrieval strength
40. Retrieval strength will indicate how easy it is to remember something
41. When you try to remember a fact that you know you know, without extra study, you strengthen the retrieval strength.
42. Elaboration and Interleaving Explain, synthesize, analyze, and apply the concepts in novel situations
43. Retrieval Practice Actively trying to remember information to make information stick in your memory better
44. Creating Self-assessments
45. Flash Cards Re-explain key ideas in simpler terms Explain your thinking out loud
46. Flash Cards Re-explain key ideas in simpler terms Explain your thinking out loud
47. ...
48. #3 - FOCUSED AND DIFFUSE MODE
49. FOCUSED MODE when you focus your attention
50. FOCUSED MODE when you focus your attention
51. DIFFUSE MODE when you relax your attention
52. DIFFUSE MODE when you relax your attention
53. FOCUSED MODE to work through familiar problems to move along pre-laid pathways in your brain to load difficult subject into your brain for diffuse mode
54. DIFFUSE MODE "aha" insights to help you understanding whatever you're learning to connect parts of your brain that may not be connected
55. It happens when you take true mental breaks
56. If you're trying to solve a completely new problem - no preexisting pathways, - it can be tough for your focused mode, since there any pathways for it to use From Learn Like a Pro
57. #4 - COGNITIVE LOAD
58. Cognitive load happens when your working memory becomes too full, so your brain cannot properly process anymore From The Programmer's Brain - Felienne Hermans
59. Long-term memory (Hard drive): when you know what to do almost automatically e.g. the syntax of a programming language Short-term memory (RAM or cache): it is used to briefly hold incoming information (limited size) e.g. when reading code, variable names, keywords, data structures, etc are temporarily stored in this memory Working memory (Processor) where the actual "thinking" happens, where we have new ideas, new solutions used for tracing: the mental compiling and executing of code
60. Long-term memory (Hard drive): when you know what to do almost automatically e.g. the syntax of a programming language Short-term memory (RAM or cache): it is used to briefly hold incoming information (limited size) e.g. when reading code, variable names, keywords, data structures, etc are temporarily stored in this memory Working memory (Processor) where the actual "thinking" happens, where we have new ideas, new solutions used for tracing: the mental compiling and executing of code
61. The working memory can only process between 2 and 6 things at a time
62. but how can we program with this limit?
63. Long-term memory (hard drive): when you know what to do almost automatically e.g. the syntax of a programming language Short-term memory (RAM or cache): it is used to briefly hold incoming information (limited size) e.g. when reading code, variable names, keywords, data structures, etc are temporarily stored in this memory Working memory (Processor) where the actual "thinking" happens, where we have new ideas, new solutions used for tracing: the mental compiling and executing of code
64. When your long-term memory has stored enough relevant information, you can remember the syntax and abstracts concepts, dividing them into chunks
65. CHUNKS "Ok/Error Tuple" "Recursion in Elixir" "Pattern matching" "Pipelines" "GenServer"
66. One chunk means one slot in the short-term memory
67. however
68. When you don't have enough knowledge in your long-term memory, you need to rely on low-level reading of code, like letters and keywords
69. It means that, instead of reading the code like this
70. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
71. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
72. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
73. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
74. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
75. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
76. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
77. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
78. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
79. Reading code as an experienced Elixir programmer defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
80. you may read the code like this
81. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
82. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
83. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
84. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
85. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
86. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
87. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
88. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
89. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
90. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
91. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
92. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
93. Reading code as a beginner defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end
94. defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Reading code as a beginner
95. defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Ah, ok! It's a protocol Reading code as a beginner
96. defprotocol Size do @doc "Calculates the size (and not the length!) of a data structure" def size(data) end defimpl Size, for: BitString do def size(string), do: byte_size(string) end defimpl Size, for: Map do def size(map), do: map_size(map) end Wait! Where is the function body? Ah, ok! It's a protocol But, how do we normally use it? Reading code as a beginner
97. You will quickly run out space in your short-term memory
98. READING CODE TOGETHER
99. Strategies from text comprehension to code
100. Activating prior knowledge Thinking of related things Monitoring Track your understanding Determining importance Relevant parts Inferring Filling in non-explicit facts Visualizing Drawing diagrams Questioning Asking questions Summarizing Creating a short summary of a text
101. The summary might be committed to the codebase as documentation
102. Reading Code is an important skill
103. Research indicates that almost 60% of programmers’ time is spent understanding code, rather than writing code. From The Programmer's Brain - Felienne Hermans
104. Code Tracing Debugging Running test
105. Inlining a function temporarily Replacing unfamiliar language constructs Drawing diagrams Using a state table
106. CODE SM ELL Long parameter List Large Module, Long Function Mysterious Name
107. +18 years after the first book 24 code smells 61 refactoring techniques 2018
108. Reviewing Code
109. Asking questions for your knowledge
110. Using git history! =D Navigating throughout the code locally Suggesting refactoring and documentation
111. PAIR CODE REVIEW
112. Learning from code and its explanation
113. Read books or blog posts about source code
114. Working with unfamiliar code?
115. Add breadcrumbs for yourself in comments indicating why you visited the code.
116. Break a task into smaller chunks
117. Label subgoals, write them down # parse message # filter by the argument # store on the database
118. WRITE CODE
119. Pair Programming
120. Create toy apps to play and practice
121. COMMUNITY SUPPORT
122. Forums
123. Groups on Telegram
124. Newsletters
125. Podcasts
126. Conferences/Meetups
127. ELUG-SP
128. Caique Mitsuoka @ Elixir Brasil 2019
132. When have I really learned Elixir?
134. RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING
135. RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING
137. STARTING WITH ELIXIR Introduction to Functional Programming Paradigm Introduction to Elixir language features: - Data types, data structures, function and module definition - Pattern matching and control flow - Recursion, Higher-Order Functions, Error handling Introduction to "Advanced" features - Concurrency primitives, fault-tolerance basis - Genservers, isolation of errors effects - Elixir/OTP GUIDE
138. THE IMPLEMENTATION
139. ~2 months dedicated to improve our Elixir/Phoenix knowledge
140. Support from the Elixir engineers, including José Valim Implementing new features from an internal project (optional) Mentoring based on the upcoming projects Self-study - with a clear goal and deadline
141. Support from the Elixir engineers, including José Valim Implementing new features from an internal project (optional) Mentoring based on the upcoming projects Self-study - with a clear goal and deadline
142. Support from the Elixir engineers, including José Valim Implementing new features from an internal project (optional) Mentoring based on the upcoming projects Self-study - with a clear goal and deadline
143. I chose to read books (in the right way)
145. exercism.org
147. AND OVERALL, IT WORKED WELL
148. Fully focus on the transition Team support More than one engineer in this transition at the same time Sharing questions and findings, including editor configuration (tooling) Sharing the "shortcuts" and challenges Documenting suggestions for future newcomers
149. Fully focus on the transition Team support More than one engineer in this transition at the same time Sharing questions and findings, including editor configuration (tooling) Sharing the "shortcuts" and challenges Documenting suggestions for future newcomers
150. ~8 new Elixir engineers in ~3 months
151. ...
152. ~16 Elixir Engineers ~12 Ruby Engineers
153. ...
154. ENGINEERING CHAPTER
156. Performance GraphQL vs Rest Code Review Event-driven architecture Inheritance vs Composition Remote work Scrum vs Kanban etc ENGINEERING CHAPTER MEETINGS every 15 days based on the project needs
157. Performance GraphQL vs Rest Code Review Event-driven architecture Inheritance vs Composition Remote work Scrum vs Kanban etc ENGINEERING CHAPTER MEETINGS every 15 days based on the project needs
158. knowledge shared and documented across teams and projects
159. knowledge shared and documented across teams and projects
160. ...
163. #5 - CONTINUOUS LEARNING
164. ELIXIR LAB
167. CARNIVAL EDITION
168. OUR GOAL to create content for newcomers in Portuguese about Elixir
169. OUR DREAM to organize a workshop as Rails Girls
170. RAILS GIRLS SÃO PAULO BRAZIL - 2019
171. OUR ONGOING PROJECT an Elixir Book Club in Portuguese
172. OUR ONGOING PROJECT to review and discuss the existent books from Elixir community
173. Started at Feb 7, 2021 Finished at May 25, 2021 9 live streams, ~2h/video Discussions in Portuguese (pt-BR) Available on Youtube Volunteer project (we spent about USD$25/month) 332 subscribers 150 views/video
175. CURRENT BOOK Programming Phoenix 1.4
176. We notify all subscribers via youtube: youtube.com/c/ElixirLabOrg And via Twitter! Follow us to know more about it =D @elaine_nw @_julianahelena @_rchc Great opportunity to learn Portuguese with different accents
177. Started at June 26th, 2021 4 live streams (and counting) ~2h/video 436 subscribers 125 views/video
179. ...
180. SUGGESTIONS AND REFERENCES
181. as a company
182. Learning Path can be an interesting tool to support your Elixir adoption strategy
183. How to build team Management of legacy systems Distribution Integration Deployment Metrics
184. Your codebase can support this process
185. https://sourcelevel.io/code-review-ebook
186. as a mentor/facilitator
190. as a self-taught, as a mentee
192. exercism.io
193. PREPARING FOR INTERVIEWS https://exercism.org/tracks/elixir https://www.hackerrank.com/domains/algorithms https://www.hackerrank.com/domains/data-structures
194. A final reminder
201. Continuous Learning is important
202. But be kind to yourself
203. Don't forget the work life balance
204. Learn how to learn
205. You can focus on being adaptable
206. You don't need to know everything
207. Each person has different skills
208. With their strengths and weakness
209. We work as team to support each other
211. speakerdeck.com/elainenaomi elainenaomi.dev Muito obrigada illustrations from undraw.co translation: thank you!!