Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Elixir Conf EU - Lessons Learned from Elixir Learning Paths

583e920a7e9238a1c21e923025f8f641?s=47 Elaine Naomi
September 10, 2021

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.

583e920a7e9238a1c21e923025f8f641?s=128

Elaine Naomi

September 10, 2021
Tweet

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)

  4. None
  5. RUA DO PARAÍSO, 595, 4TH FLOOR

  6. None
  7. None
  8. None
  9. LEARNING PATHS

  10. None
  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

  20. None
  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?

  27. None
  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
  30. None
  31. at the same time I was reading other technical books

  32. None
  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

  129. None
  130. None
  131. None
  132. When have I really learned Elixir?

  133. None
  134. RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING

  135. RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING

  136. None
  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)

  144. None
  145. exercism.org

  146. None
  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

  155. None
  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. ...

  161. None
  162. None
  163. #5 - CONTINUOUS LEARNING

  164. ELIXIR LAB

  165. None
  166. None
  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
  174. None
  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
  178. None
  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

  187. None
  188. None
  189. None
  190. as a self-taught, as a mentee

  191. None
  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

  195. None
  196. None
  197. None
  198. None
  199. None
  200. None
  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

  210. None
  211. speakerdeck.com/elainenaomi elainenaomi.dev Muito obrigada illustrations from undraw.co translation: thank you!!