狠狠撸

Micropatterns
Learning to reach for the right tool

Hi! I鈥檓 Cameron
(@cameronp)

Time for a 蝉迟辞谤测鈥�

BASIC C
Pascal
C++
PythonJava
Ruby
C#

But it didn鈥檛 work this
time鈥�

Exercises
鈥� https://projecteuler.net/
鈥� http://adventofcode.com/
鈥� http://exercism.io/

Many Small Projects > One Big Project

I was suddenly faster and more
comfortable in Elixir than in any
language I know

鈥淢颈肠谤辞辫补迟迟别谤苍蝉鈥�

def categories(num)
categories = []
while categories.length < num do
category = fetch('commerce.department')
categories << category unless categories.
include?(category)
end
categories
end
Ruby example

318,Bulah,Dicki,282,37234
306,Dante,Ankunding,285,23140
317,Monserrat,Mraz,286,35000
303,Cesar,Mann,284,54647
312,Arjun,Zulauf,286,37397
297,Ariel,Wisoky,284,31875
309,Herminia,Heaney,285,50981
310,Terrence,Macejkovic,285,38499
287,Abbigail,Miller,282,23391
282,Lavon,Kshlerin,281,46101
290,Joelle,Abbott,282,35470
. . .

defmodule Phb.Employee do
defstruct [ id: 0,
first_name: "",
last_name: "" ,
salary: 0,
manager: nil
]
end

def load(filename @default_file) do
filename
|> read
|> parse
|> validate
end

def read(file) do
file
|> File.read!
|> String.split("n", trim: true)
|> Enum.map(&String.split(&1, ","))
end

Enum.map(&String.split(&1, ","))

Micropattern #2: 鈥淪trategy鈥�
through higher order functions

Enum.map takes a 1-arity
function

But String.spit/2 is 2-
arity鈥�

iex(2)> &String.split(&1, ",")

#Function<6.50752066/1 in :erl_eval.expr/5>

iex(3)> splitByCommas = &String.split(&1, ",")

iex(3)> splitByCommas = &String.split(&1, ",")
iex(4)> splitByCommas.("1,2,3")
["1", "2", "3"]

iex(7)> Phb.Employee.Loader.load
[["318", "Bulah", "Dicki", "282", "37234"],
["306", "Dante", "Ankunding", "285", "23140"],
["317", "Monserrat", "Mraz", "286", "35000"],
["303", "Cesar", "Mann", "284", "54647"],
["312", "Arjun", "Zulauf", "286", "37397"],

Micropattern #3: Handling the
鈥淗appy Case鈥� with pattern matching

def parse_record([id_s, fname, lname, mgr_s, salary_s]),
do:

def parse_record([id_s, fname, lname, mgr_s, salary_s]),
do:
%Phb.Employee{
id: to_int(id_s),
first_name: fname,
last_name: lname,
manager: to_int(mgr_s),
salary: to_int(salary_s)
}

What if there aren鈥檛 five
elements in the list?

Well鈥� it鈥檒l crash
(And maybe that鈥檚 ok)

How can validation be thought
of in terms of transformation?

defstruct [ id: 0,
first_name: "",
last_name: "" ,
salary: 0,
manager: nil ]
end

defstruct [ id: 0,
first_name: "",
last_name: "" ,
salary: 0,
manager: nil,
errors: []]
end

def valid?(%Employee{errors[]}), do: true
def valid?(%Employee{}), do: false

def add_error(%Employee{} = e, error), do:
%Employee{e | errors: [error | e.errors]}

Ok, so we鈥檙e ready to
perform validations鈥�

Because there鈥檚 too many
micropatterns for one talk!

The #1 thing people report
as difficult:

def fetch_category, do: :rand.uniform(100)

def fetch_category, do: :rand.uniform(100)
def categories(n), do: categories(n, [])

Recursion rule #1: Think about
the termination case first

def categories(0, result), do: result

def categories(0, result), do: result
def categories(n, result) do
new = fetch_category
case (new in result) do
true -> categories(n, result)
false -> categories(n - 1, [new | result])
end
end

Let鈥檚 step back for a
moment

#1: You will become more
comfortable writing Elixir

#2: In Elixir, Micropatterns and
Patterns are the same thing

In OOP, you have objects in the
large, and methods in the small

In FP, we have functions in the
large, and functions in the small

Example: The way we added
errors to an employee struct

Example: The way we added
errors to an employee struct
def add_error(%Employee{} = e, error), do:
%Employee{e | errors: [error | e.errors]}

This is exactly how plugs
work in Phoenix

So if you get comfortable
with these small patterns鈥�

鈥� you鈥檒l find the big architectural
patterns easy to understand

Ok. Let鈥檚 try something
harder

%Employee{manager: nil,
reports: [鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥}
%Employee{
reports:[鈥

%Employee{manager: nil,
reports: [鈥}

def add_report(org, new_employee)

Takes the top of an organization, and a
new employee

Takes the top of an organization, and a
new employee
and returns either the org with the
employee added鈥� or the org
unchanged

alias Phb.Employee, as: E
def add_report(nil, %E{manager: nil} = report),
do: report

do: report
def add_report(nil, _not_a_boss), do: nil

do: report
def add_report(%E{id: m_id} = m, %E{manager:
m_id} = r) do
%E{m | reports: [r | m.reports]}
end

do: report
def add_report(%E{id: m_id} = m, %E{manager:
m_id} = r) do
%E{m | reports: [r | m.reports]}
end
def add_report(m, r) do
new_reports =
m.reports
|> Enum.map(fn rep -> add_report(rep, r) end)
%E{m | reports: new_reports}
end

def add_report(m, r) do
new_reports =
m.reports
|> Enum.map(fn rep -> add_report(rep, r) end)
%E{m | reports: new_reports}
end

def add_all_reports(reports, org)

def add_all_reports([], org), do: org

def add_all_reports([rep | rest], org) do

case add_report(org, rep) do

^org ->

^org -> add_all_reports(rest ++ [rep], org)

^org -> add_all_reports(rest ++ [rep], org)
new_org -> add_all_reports(rest, new_org)
end
end

#1: Do small problems.
Use the new patterns

Where to find small problems
鈥� adventofcode.com
鈥� exercism.io
鈥� 鈥淓xercises for Programmers鈥�, by Brian
Hogan
鈥� The Little Schemer, Friedman and Felleisen

#2: Read the Elixir source, and the
source of the better known Elixir libs

#3: Do it again and again. Mix small
problems in with your big projects

#5: Stay in touch!
I am 鈥渃ameronp鈥� on:
鈥� twitter
鈥� medium
鈥� github
鈥� gmail
鈥� elixir slack

Lightning Storm: benjaminbenson, on Flickr
Fractal: tommietheturtle, on Flickr
Construction: damienpollet, on Flickr
Photo Credits:
漏 2016, Cameron Price

狠狠撸

Micropatterns

Recommended

More Related Content

Similar to Micropatterns (20)

Recently uploaded (20)

Micropatterns