Presentation used at Avanet meetup, Medellin 2014

1. The Technical Debt of the
Programming Languages
…
and the influence in our thinking
and designs
Hernán Wilkinson
Medellin 2014
agile software development & services

2. The world “we live” in … ?

3. The world “we live” in … ?

4. The world “we live” in … ?

5. The world “we live” in … ?

6. Bret Victor - Thinking the unthinkable

7. Language implies Thinking

8. Language implies Thinking
Thinking implies Language

9. What we can not talk about…
we can not think about
(or it is difficult...)

10. Do not Insist on English

11. Aimara: Pasado y Futuro
(nayra) (qhipa)

12. Languages without a concept for the
future — "It rain tomorrow," instead
of "It will rain tomorrow" — correlate
strongly with high savings rates.

13. Now, a design problem
Let’s think about this:
How do we call the whole thing?

14. Let’s say Traffic Light (Semáforo)
How do we call each part?

15. Let’s say Traffic Regulator
(guess why not 'Traffic
Controller'?)
How do we call each Traffic Regulator in
the Traffic Light context?

16. aTrafficLight
northSouthRegulator
eastWestRegulator

17. aTrafficLight
rightRegulator
leftRegulator

18. aTrafficLight
regulator1
regulator2

19. Not easy way to name them…
Relative vs. Fix Coordinate System
B. Lee Whorf
(Linguistic Relativity)

20. What is the relationship with
Programming Languages?
(K. Iverson: “Notation as a tool of thought”)

21. If a programming
language does not
allow me to “TALK”
(write) about certain
things
…
Then I can not THINK
about certain
solutions

22. ABSTRACTION

23. How do we refer to that “thing that has
four wheels and moves?”

24. and to “that thing that moves and has
four wheels?”

25. and to “that one that
moves because it has
four wheels?”

26. To avoid REPETITION
To provide MEANING to that
REPETITION

27. Meta Note: I repeated the
picture… I’m lacking an
abstraction or a better
image! 
If we have repetition we are lacking
and abstraction… (an object in OO)

28. Let’s see
List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (customer.nameStarsWith(“H”))
selectedCustomers.add (customer);
return selectedCustomers;
List<Account> selectedAccounts = new ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw())
selectedAccounts.add(account);
return selectedAccount;
What is the problem?

29. We have repeated code!
List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (customer.nameStarsWith(“H”) )
selectedCustomers.add (customer);
return selectedCustomers;
List<Account> selectedAccounts = new ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw() )
selectedAccounts.add(account);
return selectedAccount;

30. “Repeated code” does not mean
“repeated text”.
It means “repeated patterns of
collaboration”

31. What is the problem?

32. We are lacking an
ABSTRACTION!
Repeated code means we are
forgetting an object!

33. How do we remove it?

34. Technique:
1. Copy the repeated code to some
“place”
2. Parameterize what changes
3. NAME IT!!!
4. Use it :-)

35. Copy the repeated code to some place
List<Customer> selectedCustomers =
new ArrayList<Customer> ();
for (Customer customer: customers)
if
(customer.nameStarsWith(“H”) )
selectedCustomers.add(customer);
return selectedCustomers;
List<Account> selectedAccounts = new
ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw() )
selectedAccounts.add(account);
return selectedAccount;
class Collection<T> {
public Collection<T> <<NAME>> {
List<T> selected = new ArrayList<T> ();
for (T anObject: this )
if ( )
selected.add (anObject);
return selected: }

36. Parameterize what changes
List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (customer.nameStarsWith(“H”) )
selectedCustomers.add (customer);
return selectedCustomers;
List<Account> selectedAccounts = new ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw() )
selectedAccounts.add(account);
return selectedAccount;
How do we do it?

37. We need an abstraction to represent
“code”
We need a BLOCK or a CLOSURE…
… an object that represents “code”

38. Parameterize what changes
List<Customer> selectedCustomers =
new ArrayList<Customer> ();
for (Customer customer: customers)
if
(customer.nameStarsWith(“H”) )
selectedCustomers.add(customer);
return selectedCustomers;
class Collection<T> {
public Collection<T> <<NAME>> (Closure aClosure) {
List<T> selected = new ArrayList<T> ();
for (T anObject: this)
if (aClosure.value(anObject) )
selected.add (anObject);
return selected:}
List<Account> selectedAccounts = new
ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw() )
selectedAccounts.add(account);
return selectedAccount;

39. NAME IT!!
class Collection<T> {
public Collection<T> select (Closure aClosure) {
List<T> selected = new ArrayList<T> ();
for (T anObject: this)
if (aClosure.value(anObject) )
selected.add (anObject);
return selected:}
The most difficult
part because it
means that we
understood the
repeated code
meaning
List<Customer> selectedCustomers =
new ArrayList<Customer> ();
for (Customer customer: customers)
if
(customer.nameStarsWith(“H”) )
selectedCustomers.add(customer);
return selectedCustomers;
List<Account> selectedAccounts = new
ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw() )
selectedAccounts.add(account);
return selectedAccount;

40. List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (customer.nameStarsWith(“H”))
selectedCustomers.add (customer);
return selectedCustomers;
cutomers.select( customer => customer.nameStartsWith(“H”) )
accounts.select( account => account.isOverdraw() )
List<Account> selectedAccounts = new ArrayList<Account> ();
for (Account account: accounts)
if (account.isOverdraw())
selectedAccounts.add(account);
return selectedAccount;

41. Why not an Anonymous Class?
1. Sintax:
cutomers.select( customer => customber.nameStartsWith(“H”) )
customers.select( new SelectClosure<Customer> () {
public boolean value (Customer aCustomer) {
return aCustomer.nameStartsWith(“H”); }});
Which one reads better?
2. Binding problems…

42. What did we gain?
1. Few words  Simplicity, Easier to
understand, read, remember, etc.
Less bugs!
2. We created a new “abstraction”:
select
3. … and we remove duplicated
code!!

43. Now… let’s do some reflection
1. Why didn’t we see the
“duplicated code”?
2. Why didn’t we came
with a solution?

44. Why didn’t we see the “duplicated
code”
1. Because we are use to that code (is
the programming language the
problem or us?)
2. Because there is no “concept” to
remove it

45. Why didn’t we see the “duplicated
code”
1. Because we are use to that code (is
the programming language the
problem or us?)
2. Because there is no “concept” to
remove it

46. Why didn’t we came with a solution?
1. Because the programming language
does not provide us with a
“concept” to think about a solution!
DOES NOT REALLY?

47. reject
List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (!customer.nameStarsWith(“H”))
selectedCustomers.add (customer);
return selectedCustomers;
cutomers reject: [ :aCustomer | aCustomer nameStartsWith: ‘H’ ] (Smalltalk)
customers.reject { | aCustomer | aCustomer.nameStartsWith(“H”) } (Ruby)
customers.Where( aCustomer => !aCustomer.nameStarsWith(“H”)) (C#)

48. detect
List<Customer> selectedCustomers = new ArrayList<Customer> ();
for (Customer customer: customers)
if (customer.nameStarsWith(“H”))
return customer;
throw ….
customers detect: [ :aCustomer | aCustomer nameStartsWith: ‘H’ ](Smalltalk)
customers.detect { | aCustomer | aCustomer.nameStartsWith(“H”) } (Ruby)
customers.First ( aCustomer => aCustomer.nameStarstWith(“H”)) (C#)

49. collect
List<String> customerNames = new ArrayList<String> ();
for (Customer customer: customers)
customerNames.add (customer.name());
return customerNames;
customers collect: [ :aCustomer | aCustomer name ] (Smalltalk)
customers.collect { | aCustomer | aCustomer.name () } (Ruby)
customers.Select( aCustomer => aCustomer.name() ) (C#)

50. Try {
… do something
fail()
} catch (Exception e) {
assertTrue (…. ) }
self
TDD: Test for exceptions
should: [ do something ]
raise: Exception
withExceptionDo: [ :e | self assert: …. ] (Smallalk)

51. …and much much
more….
Imagine how your
designs would be if
you could use closures
You can create your own control flow
“sintax”
Further reading: LAMBDA The Ultimate…

52. Meta-Conclusion
Object = ¿Data + Code?

53. Meta-Conclusion
Object = ¿Data + Code?
If you think so, you don´t understand OO yet

54. Mete-Conclusion
Data is an Object
Code is an Object
An Object is a “superior”
concept that unifies data and
code

55. Hamming / Closure
If there are certain objects that can not be
created in some languages …
… and given the solutions provided by some
programming languages…
The statement: “There are design solutions
that are unthinkable in some
programming languages”
¿Does it surprise you?

56. What is the problem?

57. No If!

58. If Implementation
“if” as a reserved word
– What do we gain?
– What do we loose?
“if” as a message
– What do we gain?
– What do we loose?

59. Boole’s Algebra
“if” as a message

60. Now… let’s do some reflection
1. Why didn’t we see the
“polymorphic message”?
2. Why didn’t we came
with a right solution?

61. Why didn’t we see the
“polymorphic message”
 Because 'if' as a reserved word does
not make us think in polymorphism

63. How do we model 'age'?

64. How do we model 'Weight'?

65. How do we model 'money'?
How do we model 'length'?
How do we model 'speed'?

66. We need algebraic expressions
Let's see an example

67. Now… let’s do some reflection
1. Why don't we use
algebraic expressions?
2. How does affect our
design not to use them?

68.  Because 'common programming
languages' only provide arithmetic
models
 Because we don't realize that a
language is the beginning not the
end.

69. A programming language is its
creator's state of knowledge

70. How does impact our design a
language without extensible
classes?
ArrayHelper?? xxxManager??

71. How does impact our design a
language where we can not
see how it is implemented?

72. How can we add specific behavior to
an object?
Let's see an example

73. Now… let’s do some reflection
1. What are the solutions
we lack due to limited
meta programming?
2. What do we loose if we
do not have a meta-circular
language?

74. How do we learn a new word?

75. Do we:
1. Stop our brain
2. “edit" a new definition in our
dictionary
3. “Compile” the new definition
4. Restart our brain?

76. NO!!
Why do we have to do it with our
programs?

77. Can our programs “change while
running”?
Can our programs “learn” as we learn?

78. Yes, they can!... If they are
METACIRCULAR
Apply
Eval

79. Let’s see a problem:
Can you make a proxy “learn” about its
proxee as it is used?

80. If we don’t have meta-circular
languages, then we can not think
about solutions where meta-programming
would fit!

81. Let’s think again…
Are these concepts new?

82. Lisp
John McCarthy
Alan Kay
“We must know our history
if we don’t want to reinvent
… not only the tire, but a
a flat tire”

83. Even More!
 Static vs. Dynamic typing
languages?
Design?
TDD?
 Frameworks?
 Relational Databases?
 Web applications?

84. Technical Deb Metaphor…
Fuente: http://c2.com/cgi/wiki?WardExplainsDebtMetaphor

86. Why not having closures generate
debt?
 Repeated code
 Lack of abstractions
 Difficult and costly to maintain

87. Why not having meta-programming
generate debt?
 Some problems are more difficult
to solve  More code!
 Programs can not reason about
programs or themselves
 We always need a programmer
to do something a program could
do

88. Conclusions
 Do not accept languages without
Closures
 Do not accept languages without
good meta-programming
 Create your own extensions!
 Liberate yourself from the
programming language

89. Conclusions
 Learn other programming
languages
 Lisp/Scheme
Smalltalk
 Forth and more...
 Learn our history

90. We teach this and other important
design aspects in our courses
• OO Design I & OO Design II
• TDD & Advanced TDD
Check them out at:
http://www.10pines.com/

91. Questions?

92. Muchas gracias!
agile software development & services
info@10pines.com
www.10Pines.com
twitter: @10Pines
Argentina
Tel.: +54 (11) 6091-3125
Alem 693, 5B
(1001) Buenos Aires