This document discusses simplicity and complexity in software systems. It argues that simple systems that evolve over time to become more complex tend to work better than complex systems designed from scratch. Simple is defined as having one fold or braid, while complex has many folds or braids. The document advocates embracing essential complexity but favoring simplicity overall by using higher level languages, immutable data, references to compose value and time, and avoiding mutable state. Composition is preferred over combining unrelated things. Abstractions should be global and complete rather than local and shallow.

1. Seeking Simplicity
With Phil Nash

2. seeking
Simplicity
@phil_nash

3. Whoinventedthecatflap?

4. Itis araremindindeed
thatcanrenderthe
hithertononexistent
blindingly obvious
- Dirk Gently

5. im licit =
Cm l xit =b

9. A complex system
that works is
invariably found to
have evolved from a
simple system that
worked.
Gall’s Law - 1975

10. A complex system
designed from
scratch never
works and cannot
be patched up to
make it work. You
have to start over
with a working
simple system
A complex system
that works is
invariably found to
have evolved from a
simple system that
worked.
Gall’s Law - 1975

11. For every complex
problem there is
an answer that is
clear, simple, and
wrong
H. L. Mencken?

12. Everything should be made
as simple as possible,
but no simpler
Einstein’s Razor

13. It can scarcely be denied that the
supreme goal of all theory is to make
the irreducible basic elements as
simple and as few as possible without
having to surrender the adequate
representation of a single datum of
experience.
On the Method of Theoretical Physics

14. im licit =
Cm l xit =b

15. whatis
Simplicity?

16. Rich
Hickey
S i m p l e M a d e E a s y

17. S i m p l edefine:

18. S i m p l edefine:
latin: Simplex
means: One fold / One braid

19. define:
C o m p l e x
latin: C o m p l e x u s
means: Many folds / Manybraids

20. S i m p l e
One fold/ braid
C o m p l e x
Many folds/
braids

21. Magic numbers

22. (+/-2)

30. S i m p l e
One fold/ braid
C o m p l e x
Many folds/
braids

31. S i m p l e
One fold/
braid
C o m p l e x
Many folds/
braids
E a s y H a r d

32. define:
E a s y

33. Old French: Aise
Latin (?):A d j a c e n
means: C l o s e a t Ha n d
define:
E a s y

34. E a s y
Close at hand
S i m p l e
One fold/ braid

35. C o m p l e x C o m p l i c a t e dS i m p l e
E a s y H a r d

36. TheZenof Python(extract)
Explicit is better than implicit.
Simple is better than complex. Complex is
better than complicated. Flat is better than
nested.

37. Henry Graves
Supercomplication

38. There’s an app for that

43. C o m p l i c a t e d
C o m p l e x
S i m p l e

44. C h a o t i c
C o m p l e x C o m p l i c a t e d
S i m p l e

45. D i s o r d e r
Novel practice
C h a o t i c
C o m p l e x
Emergent practice
C o m p l i c a t e d
Good practice
Best practice
S i m p l e

46. A b s t r a c t i o n

47. Joel Spolsky
All non-trivialabstractions,
tosomedegree,are leaky

48. All abstractionsare leaky
JoelSpolsky (abridged)

49. All modelsare
wrong.Butsome
are useful
George E.P. Box

50. WatertightLeaky
Easy Hard
SimpleComplex

51. Watertight
Simple
Easy

52. + -
×
√
÷

55. In mathematics, the notion of number
has been extended over the centuries
to include 0, negative numbers,
rational numbers, real numbers,
complex numbers, which extend the
real numbers by including √-1, and
sometimes additional objects
- wikipedia:
“Number”

56. Small

57. Small
Simple

58. Small
Simple
complete/
watertight shallow/leaky
global local

59. Favour higher
level languages
and language
features

60. Composition

62. Mutable state
complects value
and time

63. Refs
compose
value and time

64. class X {
fieldA
fieldB
fieldC
}

65. class X {
fieldA
fieldB
fieldC
}
x = X()

66. class X {
fieldA
fieldB
fieldC
}
x = X()
x.fieldA = …
x.fieldB = …
b = x.fieldB + x.fieldA

67. class X {
fieldA
fieldB
fieldC
}
x = X()
Immutable
x.fieldA = …
x.fieldB = …
b = x.fieldB + x.fieldA

68. x = X()
y = x with
fieldA = …
fieldB = …
x = y
class X {
fieldA
fieldB
fieldC
}
b = x.fieldB + x.fieldA
Immutable

69. x = X()
y = x with
fieldA = …
fieldB = …
b = z.fieldB + z.fieldAx = y
z = x
class X {
fieldA
fieldB
fieldC
}
Immutable

70. x = X()
y = x with
fieldA = …
fieldB = … y = x with
fieldB = …
fieldC = …
b = z.fieldB + z.fieldAx = y
z = x
x = y
class X {
fieldA
fieldB
fieldC
}
Immutable

71. x = X()
y = x with
fieldA = …
fieldB = … y = x with
fieldB = …
fieldC = …
b = z.fieldB + z.fieldAx = y
z = x
x = y
class X {
fieldA
fieldB
fieldC
}
Immutable

72. Refs
compose
value and time

73. Sim
seek
plicity
Embrace
essential
complexity

74. Sim
seek
plicity
Embrace essential complexity
Simple != easy

75. Sim
seek
plicity
Embrace essential complexity
Simple
!=easy
= few interleaving parts
Favour higher level langs/features

77. Composition
over
Complecting

78. Composition
over
Complecting
Even between value and time
Abstraction: global -> complete

79. Composition
over
Complecting
Even between value and time
Abstraction: global -> complete
local -> shallow
Avoid/ min. mutable state

80. references
levelofindirection.com/refs/simplicity.html
@phil_nash

81. One More Thing…

84. …inFolkestone!AninternationalC++conference

85. …inFolkestone!AninternationalC++conference
3daysof 4tracks
1dayworkshopclasses

86. June2020
…inFolkestone!
3daysof 4tracks
1dayworkshopclasses
AninternationalC++conference
@cpponseacpponsea.uk

87. (really)
references
levelofindirection.com/refs/simplicity.html
@phil_nash