The building metaphor that is so often applied to software development is broken. Why do we need to start with the foundations first? The roof we’re building is virtual, it can float! So why not build it first? Or even better just the part that we need first. We’re so used to building software from the bottom up that we don’t even realise that it involves an incredible amount of guess work and ultimately results in a lot of hidden waste. In this talk I examine and challenge current thinking about the order in which we build software, thinking which I believe has been perpetuated by the building metaphor we use when we teach new software developers and when we communicate with non-developers in the industry.

1. Build the Roof
First
Brendon Page
@brendonpaginate

2. Who are you?
Developer
Engineer
Architect
Craftsmen

3. Overview
Challenge your
thinking on the
order in which
software is built

4. The
Wright
Brothers

5. Metaphor
Ship as
Aircraft
-VS-
Bicycle as
Aircraft

6. “The very ability that
allows us to
comprehend one
concept in terms of
another will necessarily
hide aspects of the
concept”

7. Ship metaphor
hides aspects
about aircraft
that the
bicycle metaphor
doesn’t
Stability

8. Are we like the
ship builders?

9. What is the
metaphor of
our industry?

10. Building
Metaphor

11. Is it hiding
anything?

12. What
aspects of
the
metaphor
don’t exist
in the
software
world but
manifest

13. Gravity
&
Hard to
change

14. Examine these in
terms of
Point of input
&
Direction of
execution

15. Quick definition
check

16. Point of input
“Any point at
which data enters
the system”

17. Point of input
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

18. Point of input
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

19. Direction of
Execution
“The order in
which code runs”

20. Direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

21. Direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

22. Gravity

23. In the
physical world
You can’t build
on top of nothing

24. Manifests in the
software world as
You can’t call
something that
doesn’t exist

25. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

26. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

27. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

28. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

29. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

30. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Against
direction
of
execution

31. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Start is far
from point
of input

32. What is the cost?

33. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

34. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Need to
guess all
the way to
the point of
input
guessing = hard, time consuming, open mistakes

35. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
…
…
…
Program.Load()
Greater the
distance
from point
of input,
greater the
more
guessing
needed

36. What is the
hidden option?

37. Currently
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Against
direction
of
execution

38. Hidden option
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
With
direction
of
execution

39. Code in direction of execution
Start at point
of input
Code in
direction
of
execution

40. Code in direction of execution
Program.Main(string[] args)
Start at point
of input
Code in
direction
of
execution

41. Code in direction of execution
Program.Main(string[] args)
Program.Calculate()
Start at point
of input
Code in
direction
of
execution

42. Code in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Start at point
of input
Code in
direction
of
execution

43. Code in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Start at point
of input
Code in
direction
of
execution

44. Refactor in direction of execution
Start at point
of input
Refactor in
direction
of
execution

45. Refactor in direction of execution
Program.Main(string[] args)
Start at point
of input
Refactor in
direction
of
execution

46. Refactor in direction of execution
Program.Main(string[] args)
Program.Calculate()
Start at point
of input
Refactor in
direction
of
execution

47. Refactor in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Start at point
of input
Refactor in
direction
of
execution

48. Refactor in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Start at point
of input
Refactor in
direction
of
execution

49. Abstract in direction of execution
Start at point
of input
Abstract in
direction
of
execution

50. Abstract in direction of execution
Program.Main(string[] args)
Start at point
of input
Abstract in
direction
of
execution

51. Abstract in direction of execution
Program.Main(string[] args)
ICalculator.Calculate()
Start at point
of input
Abstract in
direction
of
execution

52. Abstract in direction of execution
Program.Main(string[] args)
ICalculator.Calculate()
AlwaysZeroCalculator.Calculate()
Start at point
of input
Abstract in
direction
of
execution

53. Abstract in direction of execution
Program.Main(string[] args)
ICalculator.Calculate()
RealDealValidator.Calculate()
Start at point
of input
Abstract in
direction
of
execution

54. Abstract in direction of execution
Program.Main(string[] args)
ICalculator.Calculate()
RealDealValidator.Calculate()
IRepository.Load()
…
Start at point
of input
Abstract in
direction
of
execution

55. Hidden option
Start at point
of input
Build in
direction
of
execution

56. Hard to change

57. In the
physical world
Things are hard
to change once
built without
destroying them

58. Manifests in the
software world as
Code is hard to
change so it
needs to be built
right the first
time

59. Hard to change in the software
world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

60. Hard to change in the software
world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load() Build all of
this

61. Hard to change in the software
world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Then build
all of this

62. Hard to change in the software
world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Then build
all of this

63. Hard to change in the software
world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Before you
get to the
point of
input

64. What is the cost?

65. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Risk
building
unneeded
or incorrect
things

66. Gravity in the software world
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Takes long
to build,
can only get
feedback
when point
of input is
reached

67. What is the
hidden option?

68. Currently
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

69. Hidden option
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()

70. Iterate in direction of execution
Start at point
of input
Iterate in
direction
of
execution

71. Iterate in direction of execution
Program.Main(string[] args)
Start at point
of input
Iterate in
direction
of
execution
Only
building as
much as
you need

72. Iterate in direction of execution
Program.Main(string[] args)
Program.Calculate()
Start at point
of input
Iterate in
direction
of
execution
Only
building as
much as
you need

73. Iterate in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Start at point
of input
Iterate in
direction
of
execution
Only
building as
much as
you need

74. Iterate in direction of execution
Program.Main(string[] args)
Program.Calculate()
Program.Find()
Program.Load()
Start at point
of input
Iterate in
direction
of
execution
Only
building as
much as
you need

75. Hidden option
Start at point
of input
Iterate in
direction
of
execution

76. Review
Build
against
direction
of
execution
Gravit
y
Build the
whole of what
we’ve guessed
Hard to
change
Start far
from point
of input
Lengthens
feedback
loops
Requires
guessing what
to build

77. Review
Build in
direction
of
execution
Only building enough to
know what to build next
Start at
point of
input
Shortens
feedback
loops
Removes need
for guessing
what to build

78. Build the roof
first

79. Three rules of building the roof
first
1. Start at the point of input that
adds the most value.
2. Build in the direction of
execution.
3. Only build enough to know
what to build next in the
direction of execution.

80. Summary
Think about the
order in which
you build
software

81. Regardless of the
metaphor you
use,
ask what it is
hiding from you

82. Thank you!
Questions?
@brendonpaginate