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

Elixir Conf EU - Lessons Learned from Elixir Learning Paths

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.

Elaine Naomi

September 10, 2021
Tweet

More Decks by Elaine Naomi

Other Decks in Programming

Transcript

  1. Software Engineer/Developer (since 2008) B.Sc. in Computer Engineering M.Sc. in

    Computer Science Software Engineer at The RealReal ELAINE NAOMI WATANABE
  2. LEARNING PATH An organized set of learning activities that allows

    building knowledge progressively https://en.wikipedia.org/wiki/Learning_pathway
  3. Learning about a subject Outside the classroom Without direct supervision

    Self-paced Learning SELF-STUDY / SELF-LEARNING
  4. 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?
  5. ...

  6. 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?
  7. But, after two days, you will remember of 25% of

    what you have learned The Forgetting Curve
  8. When you try to remember a fact that you know

    you know, without extra study, you strengthen the retrieval strength.
  9. ...

  10. 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
  11. DIFFUSE MODE "aha" insights to help you understanding whatever you're

    learning to connect parts of your brain that may not be connected
  12. 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
  13. Cognitive load happens when your working memory becomes too full,

    so your brain cannot properly process anymore From The Programmer's Brain - Felienne Hermans
  14. 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
  15. 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
  16. 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
  17. When your long-term memory has stored enough relevant information, you

    can remember the syntax and abstracts concepts, dividing them into chunks
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. 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
  31. 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
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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
  43. 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
  44. 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
  45. 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
  46. Research indicates that almost 60% of programmers’ time is spent

    understanding code, rather than writing code. From The Programmer's Brain - Felienne Hermans
  47. Label subgoals, write them down # parse message # filter

    by the argument # store on the database
  48. 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
  49. 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
  50. 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
  51. 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
  52. 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
  53. 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
  54. ...

  55. ...

  56. 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
  57. 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
  58. ...

  59. 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
  60. 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
  61. Started at June 26th, 2021 4 live streams (and counting)

    ~2h/video 436 subscribers 125 views/video
  62. ...