Slides from my Empex 2016 talk.

1. Micropatterns
Learning to reach for the right tool

2. Hi! I’m Cameron
(@cameronp)

8. Time for a story…

9. October, 2014

11. BASIC C
Pascal
C++
PythonJava
Ruby
C#

13. But it didn’t work this
time…

14. Time passes…

18. Exercises
• https://projecteuler.net/
• http://adventofcode.com/
• http://exercism.io/

19. Many Small Projects > One Big Project

20. And this time it stuck

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

22. What happened?

23. OTP?

24. Nope

25. “Micropatterns”

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

29. Mutation vs Transformation

30. Mutation vs Transformation

31. Micropattern #1: Pipelines

32. “Real World” Example

33. 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
. . .

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

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

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

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

38. Micropattern #2: “Strategy”
through higher order functions

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

40. Enum.map takes a 1-arity
function

41. But String.spit/2 is 2-
arity…

42. What to do?

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

44. iex(2)> &String.split(&1, ",")
#Function<6.50752066/1 in :erl_eval.expr/5>

45. iex(2)> &String.split(&1, ",")
#Function<6.50752066/1 in :erl_eval.expr/5>
iex(3)> splitByCommas = &String.split(&1, ",")
#Function<6.50752066/1 in :erl_eval.expr/5>

46. iex(2)> &String.split(&1, ",")
#Function<6.50752066/1 in :erl_eval.expr/5>
iex(3)> splitByCommas = &String.split(&1, ",")
#Function<6.50752066/1 in :erl_eval.expr/5>
iex(4)> splitByCommas.("1,2,3")
["1", "2", "3"]

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

48. 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"],

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

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

51. Micropattern #3: Handling the
“Happy Case” with pattern matching

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

53. 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)
}

54. What if there aren’t five
elements in the list?

55. Well… it’ll crash

56. Well… it’ll crash
(And maybe that’s ok)

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

58. How can validation be thought
of in terms of transformation?

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

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

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

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

63. Ok, so we’re ready to
perform validations…

64. But I’m not going to..

65. Because there’s too many
micropatterns for one talk!

66. The #1 thing people report
as difficult:

67. Recursion.

68. Recursion.

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

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

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

72. Recursion rule #1: Think about
the termination case first

73. def categories(n), do: categories(n, [])
def categories(0, result), do: result

74. def categories(n), do: categories(n, [])
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

75. Let’s step back for a
moment

76. Why are we doing this?

77. Two reasons

78. #1: You will become more
comfortable writing Elixir

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

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

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

83. Example: The way we added
errors to an employee struct

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

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

86. This is exactly how plugs
work in Phoenix

87. So if you get comfortable
with these small patterns…

88. … you’ll find the big architectural
patterns easy to understand

90. Ok. Let’s try something
harder

91. 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
. . .

92. %Employee{manager: nil,
reports: […]}
%Employee{
reports:[…]}
%Employee{
reports:[…]}
%Employee{
reports:[…]}
%Employee{
reports:[…]}
%Employee{
reports:[…]}
%Employee{
reports:[…]}
%Employee{
reports:[…]

93. Where to begin?

94. %Employee{manager: nil,
reports: […]}

95. def add_report(org, new_employee)

96. def add_report(org, new_employee)
Takes the top of an organization, and a
new employee

97. def add_report(org, 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

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

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

100. alias Phb.Employee, as: E
def add_report(nil, %E{manager: nil} = report),
do: report
def add_report(nil, _not_a_boss), do: nil
def add_report(%E{id: m_id} = m, %E{manager:
m_id} = r) do
%E{m | reports: [r | m.reports]}
end

101. alias Phb.Employee, as: E
def add_report(nil, %E{manager: nil} = report),
do: report
def add_report(nil, _not_a_boss), do: nil
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

102. 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

103. def add_all_reports(reports, org)

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

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

106. def add_all_reports([], org), do: org
def add_all_reports([rep | rest], org) do
case add_report(org, rep) do

107. def add_all_reports([], org), do: org
def add_all_reports([rep | rest], org) do
case add_report(org, rep) do
^org ->

108. def add_all_reports([], org), do: org
def add_all_reports([rep | rest], org) do
case add_report(org, rep) do
^org -> add_all_reports(rest ++ [rep], org)

109. def add_all_reports([], org), do: org
def add_all_reports([rep | rest], org) do
case add_report(org, rep) do
^org -> add_all_reports(rest ++ [rep], org)
new_org -> add_all_reports(rest, new_org)
end
end

110. Easy, right?

111. No?

112. Be not afraid

113. Next steps:

114. #1: Do small problems.
Use the new patterns

115. Where to find small problems
• adventofcode.com
• exercism.io
• “Exercises for Programmers”, by Brian
Hogan
• The Little Schemer, Friedman and Felleisen

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

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

118. #5: Stay in touch!
I am “cameronp” on:
• twitter
• medium
• github
• gmail
• elixir slack

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