Tweet
Tweet

Slide 1

Slide 1 text

Elixir LEARNING PATHS Lessons Learned

Slide 2

Slide 2 text

Software Engineer/Developer (since 2008) B.Sc. in Computer Engineering M.Sc. in Computer Science Software Engineer at The RealReal ELAINE NAOMI WATANABE

Slide 3

Slide 3 text

São Paulo / Brazil (GMT -3:00)

Slide 4

Slide 4 text

No content

Slide 5

Slide 5 text

RUA DO PARAÍSO, 595, 4TH FLOOR

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

No content

Slide 9

Slide 9 text

LEARNING PATHS

Slide 10

Slide 10 text

No content

Slide 11

Slide 11 text

LEARNING PATH An organized set of learning activities that allows building knowledge progressively https://en.wikipedia.org/wiki/Learning_pathway

Slide 12

Slide 12 text

exercism.org/tracks/elixir/concepts

Slide 13

Slide 13 text

#1 - LEARNING PATH VS SELF-STUDY

Slide 14

Slide 14 text

Measured Time to Proficiency Definition of Proficiency Documented Content and Activities Evaluation and Revision LEARNING PATH

Slide 15

Slide 15 text

Learning about a subject Outside the classroom Without direct supervision Self-paced Learning SELF-STUDY / SELF-LEARNING

Slide 16

Slide 16 text

SELF-STUDY CHALLENGES What to learn? Which resources can I use?

Slide 17

Slide 17 text

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?

Slide 18

Slide 18 text

elixir-lang.org

Slide 19

Slide 19 text

elixirschool.com

Slide 20

Slide 20 text

No content

Slide 21

Slide 21 text

exercism.org

Slide 22

Slide 22 text

exercism.io

Slide 23

Slide 23 text

exercism.org/tracks/elixir/concepts

Slide 24

Slide 24 text

...

Slide 25

Slide 25 text

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?

Slide 26

Slide 26 text

How to learn? How to improve the learning process?

Slide 27

Slide 27 text

No content

Slide 28

Slide 28 text

Focus Self-Discipline Motivation Study plan Time and energy management How to study / read effectively

Slide 29

Slide 29 text

I thought that just reading a book would be enough to learn basic Elixir concepts

Slide 30

Slide 30 text

No content

Slide 31

Slide 31 text

at the same time I was reading other technical books

Slide 32

Slide 32 text

No content

Slide 33

Slide 33 text

At the end of that book club, I forgot everything I learned about Elixir

Slide 34

Slide 34 text

#2 - SPACED LEARNING

Slide 35

Slide 35 text

The learning happens when you sleep

Slide 36

Slide 36 text

But, after two days, you will remember of 25% of what you have learned The Forgetting Curve

Slide 37

Slide 37 text

The more you repeatedly study something, the stronger the memory of it is Storage Strength

Slide 38

Slide 38 text

However, only repetition is not enough

Slide 39

Slide 39 text

We need to strengthen the retrieval strength

Slide 40

Slide 40 text

Retrieval strength will indicate how easy it is to remember something

Slide 41

Slide 41 text

When you try to remember a fact that you know you know, without extra study, you strengthen the retrieval strength.

Slide 42

Slide 42 text

Elaboration and Interleaving Explain, synthesize, analyze, and apply the concepts in novel situations

Slide 43

Slide 43 text

Retrieval Practice Actively trying to remember information to make information stick in your memory better

Slide 44

Slide 44 text

Creating Self-assessments

Slide 45

Slide 45 text

Flash Cards Re-explain key ideas in simpler terms Explain your thinking out loud

Slide 46

Slide 46 text

Flash Cards Re-explain key ideas in simpler terms Explain your thinking out loud

Slide 47

Slide 47 text

...

Slide 48

Slide 48 text

#3 - FOCUSED AND DIFFUSE MODE

Slide 49

Slide 49 text

FOCUSED MODE when you focus your attention

Slide 50

Slide 50 text

FOCUSED MODE when you focus your attention

Slide 51

Slide 51 text

DIFFUSE MODE when you relax your attention

Slide 52

Slide 52 text

DIFFUSE MODE when you relax your attention

Slide 53

Slide 53 text

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

Slide 54

Slide 54 text

DIFFUSE MODE "aha" insights to help you understanding whatever you're learning to connect parts of your brain that may not be connected

Slide 55

Slide 55 text

It happens when you take true mental breaks

Slide 56

Slide 56 text

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

Slide 57

Slide 57 text

#4 - COGNITIVE LOAD

Slide 58

Slide 58 text

Cognitive load happens when your working memory becomes too full, so your brain cannot properly process anymore From The Programmer's Brain - Felienne Hermans

Slide 59

Slide 59 text

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

Slide 60

Slide 60 text

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

Slide 61

Slide 61 text

The working memory can only process between 2 and 6 things at a time

Slide 62

Slide 62 text

but how can we program with this limit?

Slide 63

Slide 63 text

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

Slide 64

Slide 64 text

When your long-term memory has stored enough relevant information, you can remember the syntax and abstracts concepts, dividing them into chunks

Slide 65

Slide 65 text

CHUNKS "Ok/Error Tuple" "Recursion in Elixir" "Pattern matching" "Pipelines" "GenServer"

Slide 66

Slide 66 text

One chunk means one slot in the short-term memory

Slide 67

Slide 67 text

however

Slide 68

Slide 68 text

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

Slide 69

Slide 69 text

It means that, instead of reading the code like this

Slide 70

Slide 70 text

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

Slide 71

Slide 71 text

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

Slide 72

Slide 72 text

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

Slide 73

Slide 73 text

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

Slide 74

Slide 74 text

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

Slide 75

Slide 75 text

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

Slide 76

Slide 76 text

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

Slide 77

Slide 77 text

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

Slide 78

Slide 78 text

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

Slide 79

Slide 79 text

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

Slide 80

Slide 80 text

you may read the code like this

Slide 81

Slide 81 text

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

Slide 82

Slide 82 text

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

Slide 83

Slide 83 text

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

Slide 84

Slide 84 text

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

Slide 85

Slide 85 text

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

Slide 86

Slide 86 text

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

Slide 87

Slide 87 text

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

Slide 88

Slide 88 text

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

Slide 89

Slide 89 text

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

Slide 90

Slide 90 text

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

Slide 91

Slide 91 text

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

Slide 92

Slide 92 text

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

Slide 93

Slide 93 text

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

Slide 94

Slide 94 text

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

Slide 95

Slide 95 text

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

Slide 96

Slide 96 text

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

Slide 97

Slide 97 text

You will quickly run out space in your short-term memory

Slide 98

Slide 98 text

READING CODE TOGETHER

Slide 99

Slide 99 text

Strategies from text comprehension to code

Slide 100

Slide 100 text

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

Slide 101

Slide 101 text

The summary might be committed to the codebase as documentation

Slide 102

Slide 102 text

Reading Code is an important skill

Slide 103

Slide 103 text

Research indicates that almost 60% of programmers’ time is spent understanding code, rather than writing code. From The Programmer's Brain - Felienne Hermans

Slide 104

Slide 104 text

Code Tracing Debugging Running test

Slide 105

Slide 105 text

Inlining a function temporarily Replacing unfamiliar language constructs Drawing diagrams Using a state table

Slide 106

Slide 106 text

CODE SM ELL Long parameter List Large Module, Long Function Mysterious Name

Slide 107

Slide 107 text

+18 years after the first book 24 code smells 61 refactoring techniques 2018

Slide 108

Slide 108 text

Reviewing Code

Slide 109

Slide 109 text

Asking questions for your knowledge

Slide 110

Slide 110 text

Using git history! =D Navigating throughout the code locally Suggesting refactoring and documentation

Slide 111

Slide 111 text

PAIR CODE REVIEW

Slide 112

Slide 112 text

Learning from code and its explanation

Slide 113

Slide 113 text

Read books or blog posts about source code

Slide 114

Slide 114 text

Working with unfamiliar code?

Slide 115

Slide 115 text

Add breadcrumbs for yourself in comments indicating why you visited the code.

Slide 116

Slide 116 text

Break a task into smaller chunks

Slide 117

Slide 117 text

Label subgoals, write them down # parse message # filter by the argument # store on the database

Slide 118

Slide 118 text

WRITE CODE

Slide 119

Slide 119 text

Pair Programming

Slide 120

Slide 120 text

Create toy apps to play and practice

Slide 121

Slide 121 text

COMMUNITY SUPPORT

Slide 122

Slide 122 text

Forums

Slide 123

Slide 123 text

Groups on Telegram

Slide 124

Slide 124 text

Newsletters

Slide 125

Slide 125 text

Podcasts

Slide 126

Slide 126 text

Conferences/Meetups

Slide 127

Slide 127 text

ELUG-SP

Slide 128

Slide 128 text

Caique Mitsuoka @ Elixir Brasil 2019

Slide 129

Slide 129 text

No content

Slide 130

Slide 130 text

No content

Slide 131

Slide 131 text

No content

Slide 132

Slide 132 text

When have I really learned Elixir?

Slide 133

Slide 133 text

No content

Slide 134

Slide 134 text

RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING

Slide 135

Slide 135 text

RUBY TO ELIXIR ONBOARDING MENTORING OF FACILITATORS CONTINUOUS LEARNING

Slide 136

Slide 136 text

No content

Slide 137

Slide 137 text

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

Slide 138

Slide 138 text

THE IMPLEMENTATION

Slide 139

Slide 139 text

~2 months dedicated to improve our Elixir/Phoenix knowledge

Slide 140

Slide 140 text

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

Slide 141

Slide 141 text

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

Slide 142

Slide 142 text

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

Slide 143

Slide 143 text

I chose to read books (in the right way)

Slide 144

Slide 144 text

No content

Slide 145

Slide 145 text

exercism.org

Slide 146

Slide 146 text

No content

Slide 147

Slide 147 text

AND OVERALL, IT WORKED WELL

Slide 148

Slide 148 text

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

Slide 149

Slide 149 text

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

Slide 150

Slide 150 text

~8 new Elixir engineers in ~3 months

Slide 151

Slide 151 text

...

Slide 152

Slide 152 text

~16 Elixir Engineers ~12 Ruby Engineers

Slide 153

Slide 153 text

...

Slide 154

Slide 154 text

ENGINEERING CHAPTER

Slide 155

Slide 155 text

No content

Slide 156

Slide 156 text

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

Slide 157

Slide 157 text

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

Slide 158

Slide 158 text

knowledge shared and documented across teams and projects

Slide 159

Slide 159 text

knowledge shared and documented across teams and projects

Slide 160

Slide 160 text

...

Slide 161

Slide 161 text

No content

Slide 162

Slide 162 text

No content

Slide 163

Slide 163 text

#5 - CONTINUOUS LEARNING

Slide 164

Slide 164 text

ELIXIR LAB

Slide 165

Slide 165 text

No content

Slide 166

Slide 166 text

No content

Slide 167

Slide 167 text

CARNIVAL EDITION

Slide 168

Slide 168 text

OUR GOAL to create content for newcomers in Portuguese about Elixir

Slide 169

Slide 169 text

OUR DREAM to organize a workshop as Rails Girls

Slide 170

Slide 170 text

RAILS GIRLS SÃO PAULO BRAZIL - 2019

Slide 171

Slide 171 text

OUR ONGOING PROJECT an Elixir Book Club in Portuguese

Slide 172

Slide 172 text

OUR ONGOING PROJECT to review and discuss the existent books from Elixir community

Slide 173

Slide 173 text

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

Slide 174

Slide 174 text

No content

Slide 175

Slide 175 text

CURRENT BOOK Programming Phoenix 1.4

Slide 176

Slide 176 text

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

Slide 177

Slide 177 text

Started at June 26th, 2021 4 live streams (and counting) ~2h/video 436 subscribers 125 views/video

Slide 178

Slide 178 text

No content

Slide 179

Slide 179 text

...

Slide 180

Slide 180 text

SUGGESTIONS AND REFERENCES

Slide 181

Slide 181 text

as a company

Slide 182

Slide 182 text

Learning Path can be an interesting tool to support your Elixir adoption strategy

Slide 183

Slide 183 text

How to build team Management of legacy systems Distribution Integration Deployment Metrics

Slide 184

Slide 184 text

Your codebase can support this process

Slide 185

Slide 185 text

https://sourcelevel.io/code-review-ebook

Slide 186

Slide 186 text

as a mentor/facilitator

Slide 187

Slide 187 text

No content

Slide 188

Slide 188 text

No content

Slide 189

Slide 189 text

No content

Slide 190

Slide 190 text

as a self-taught, as a mentee

Slide 191

Slide 191 text

No content

Slide 192

Slide 192 text

exercism.io

Slide 193

Slide 193 text

PREPARING FOR INTERVIEWS https://exercism.org/tracks/elixir https://www.hackerrank.com/domains/algorithms https://www.hackerrank.com/domains/data-structures

Slide 194

Slide 194 text

A final reminder

Slide 195

Slide 195 text

No content

Slide 196

Slide 196 text

No content

Slide 197

Slide 197 text

No content

Slide 198

Slide 198 text

No content

Slide 199

Slide 199 text

No content

Slide 200

Slide 200 text

No content

Slide 201

Slide 201 text

Continuous Learning is important

Slide 202

Slide 202 text

But be kind to yourself

Slide 203

Slide 203 text

Don't forget the work life balance

Slide 204

Slide 204 text

Learn how to learn

Slide 205

Slide 205 text

You can focus on being adaptable

Slide 206

Slide 206 text

You don't need to know everything

Slide 207

Slide 207 text

Each person has different skills

Slide 208

Slide 208 text

With their strengths and weakness

Slide 209

Slide 209 text

We work as team to support each other

Slide 210

Slide 210 text

No content

Slide 211

Slide 211 text

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