CocoaConf Relationship Between Agility and Expertise

Crafting software systems for
forward-thinking businesses

Ken Auer
@kauerrolemodel
Agility &
Expertise
The Relationship Between
ken.auer@rolemodelsoftware.com
http://www.slideshare.net/kauerrolemodel/

the-relationship-between-agility-and-expertise

Complexity
Longevity
Software Explained

Complexity
Longevity
Inexpensive
Expensive
Software Explained

Complexity
Longevity
Inexpensive
Expensive
Software Explained 
Simple
Website

Complexity
Longevity
Inexpensive
Expensive
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Impressive
prototype
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Website/app
promoting a
new product
Impressive
prototype
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Website/app
promoting a
new product
Impressive
prototype
Election results
reporting system
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Website/app
promoting a
new product
Impressive
prototype
Record-keeping
system subject to
changing regulations
Election results
reporting system
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Website/app
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting system
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Inexpensive
Expensive
Website/app
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting system
Simple
Website
MyFirst
TwilioApp Consumables Investments

* http://litemind.com/expert-roadmap/
Dreyfus Model of
Skill Acquisition* 
Rules Detached
Observer
Considers 
Everything
Intuition
Relevant 
Focus
Part of 
System
Novice
Advanced Beginner
Competent
Proﬁcient
Expert

Knowledge vs. Skill* 
“There’s much more to mastering a skill than
just acquiring more knowledge. Just like adults
are not simply bigger children, experts are not
only smarter, more knowledgeable or faster than
novices. The differences can be found at a more
fundamental level, such as in how they perceive
the world and approach problems.”
- Luciano Passuello
* http://litemind.com/expert-roadmap/

Knowledge vs. Skill* 
“There’s much more to mastering a skill than
just acquiring more knowledge. Just like adults
are not simply bigger children, experts are not
only smarter, more knowledgeable or faster than
novices. The differences can be found at a more
fundamental level, such as in how they perceive
the world and approach problems.”
- Luciano Passuello
* http://litemind.com/expert-roadmap/ 
** https://www.amazon.com/Reﬂective-Practitioner-Professionals-Think-Action/dp/0465068782

Cost of Advanced Beginners 
Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Make it run... right?
All of us are Novices at some things...  
Some may be experts in others...
Usually somewhere in between
Tools
TechniquesSkills
DomainsLanguages

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Follow rules on well-deﬁned tasks

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Complete similar tasks following rules

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Have conceptual models in which to operate

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Have conceptual framework in which to adjust

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Intuitively identify and solve problems... it’s simple

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Overwhelmed by Complexity

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Manage and Reduce Complexity

Novice
Advanced Beginner
Competent
Proﬁcient
Expert
Clueless
Mostly “right”
Tools
TechniquesSkills
DomainsLanguages
Manage and Reduce Complexity
Unwittingly Introduce Complexity

Benefits of Reflective Expertise InherentComplexity
Longevity
Novice
Adv. Beginner
Competent
Proficient
Expert

InherentComplexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
Consumable Applications 
“Deliver Fast, for Immediate Needs”

It is All About Speed
• Well-deﬁned functionality in well-deﬁned
domain

domain
• Well-deﬁned technology stack appropriate
for delivery medium

domain
for delivery medium
• Put it in front of users, hope they are happy…  
if they are not, move on

domain
for delivery medium
• Put it in front of users, hope they are happy…  
if they are not, move on
• Can become
➡ Advanced Beginner in months
➡ Proﬁcient in 2-3 years
➡ Expert in < 5 years? (10,000 hours)

Software Assets 
“Supporting Business, Expanding Business”
InherentComplexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert

It is a Marathon
• Leveraging expertise in changing domain

It is a Marathon
• Technology needs to be helpful, not ﬂeeting,
and forward moving

It is a Marathon
and forward moving
• If people are not happy, business might stop

It is a Marathon
and forward moving
• If people are not happy, business might stop
• Domain and Technical Skills both really
important
• Green ﬁelds are hard to ﬁnd
• Typically deep domain model, not just UI
• Many communication challenges
• Learning Environment

Short-term vs. Long-term 
“code is read more often than it is written”*
2-4x 4-10x 10-100x
* attributed to many… if you think you are the ﬁrst to say it, please correct Google
InherentComplexity
Longevity
Time spent reading code vs. writing code
Code Read vs. Written

Benefits of Reflective Expertise 
“code is read more often than it is written”*
10-100x
4-10x
1x
TimetoGrasp&
EffectivelyExpress
2-4x
1-2x
2-4x 4-10x 10-100x
Code Read vs. Written
InherentComplexity
Longevity
Novice
Adv. Beginner
Competent
Proficient
Expert

Costs of Less Skilled Producers
* https://en.wikipedia.org/wiki/Technical_debt (paraphrased)
Technical debt is a metaphor referring to
the eventual consequences of any
development within a codebase. The
debt can be thought of as work that
needs to be done before a particular job
can be considered complete or proper. If
the debt is not repaid, then it will keep
on accumulating “interest,” making it
hard to implement changes later on.
“don’t confuse speed/motion with progress”

1x
10-100x
TechnicalDebt 
IntroductionRate
4-10x
2-4x
1-2x
Costs of Less Skilled Producers 
“don’t confuse speed/motion with progress”*
IntroducedComplexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert

Complexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
Hitting the Target w/Software 
Website/App
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting
system
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
Website/App
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting
system
Turning a
Prototype that
was shipped into
a Software Asset
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
Website/App
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting
system
Turning a system
built with a
Consumable
mindset into a
Software Asset
Turning a
Prototype that
was shipped into
a Software Asset
Simple
Website
MyFirst
TwilioApp

Complexity
Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
Website/App
promoting a
new product
Impressive
prototype
Decision
Support system
for experts in a
changing domain
Record-keeping
system subject to
Election results
reporting
system
Turning a system
built with a
Consumable
mindset into a
Software Asset
Turning a System
built by less
skilled producers
into a Software
Asset
Turning a
Prototype that
was shipped into
a Software Asset
Simple
Website
MyFirst
TwilioApp

The
Uncomfortable Reality
• “We only hire smart people”

The
• Are all of your people  
really experts?

The
really experts?
• Compared to the guys who
wrote the Agile Manifesto?

The
really experts?
• Experts are hard to ﬁnd, cost lots of
money, and don’t like simple tasks  
(or cleaning up others messes)

The
really experts?
• To a manager (novice?) everyone
who knows more than him looks
like an expert

The
really experts?
• To a manager (novice?) everyone
who knows more than him looks
like an expert
• To an advanced
beginner, everyone
who knows less
than him looks like
an idiot

Novice
Adv. Beg
Competent
Proﬁcient
Expert
Example 
Weak 
Professional 
Developer 
Skill 
Scorecard

The Good News
• We have learned “best practices”

The Good News
• Nearly anyone can do them  
(or learn to do them)

The Good News
• Doing them will

The Good News
• Doing them will
• Make them better

The Good News
• Doing them will
• Reduce your risk

The Good News
• Doing them will
• Reduce your risk
• Not all tasks, even on a complex  
system, require an expert

* http://agilemanifesto.org/ 
See http://agilemanifesto.org/principles.html for better description of “agile”

SCRUM - Simple Agile 
Customer Feedback

eXtreme Programming
Continuous Reﬁnement of...
• Requirements
• Design
• Plan
• People
• Results
Potential Value!
?

eXtreme Programming
code reviews
testing
design
simplicity
customer involvement
integration
short iterations
risk management
pair programming
100% unit, tracking acceptance
continuous refactoring
TSTTCPW, YAGNI, test-driven
they drive
daily or more often
1-4 week release cycle
collective code ownership
=>
=>
=>
=>
=>
=>
=>
=>

TDD, Refactoring, Pairing +
Collective Code Ownership

• Achieve validated quality code

• Shared learning

• Shared learning
• In context

• Shared learning
• In context
• For context

• Shared learning
• In context
• For context
• Anyone(?) can keep it going forward with
quality

SCRUM vs. eXtreme 
Surface vs. Deep

Surface vs. Deep
• SCRUM certiﬁcation means you sat
through a class

Surface vs. Deep
through a class
• Tells you to have feedback loops

Surface vs. Deep
through a class
• No programming approach

Surface vs. Deep
through a class
• eXtreme Programming more deeply
addresses approach to programming…

Surface vs. Deep
through a class
• eXtreme Programming more deeply
addresses approach to programming…
• …and makes you a better programmer?

Complexity
Longevity
Beneﬁts of Deep Agility 
Customer Feedback
Continuous Integration
Test-Driven
Pair Programming
Iteration Planning
Continuous Refactoring
More depth puts in
more checks against
introduced complexity
and more results that
reduce business riskStand-up Meetings

Reality of Internal Quality 
• Easy for anyone to slip in the name of expediency

• Make it run. Make it right. Make it fast. OR

• Make it run... fast enough?… Ship it.

• Make it right?

• Make it right?
• Limited by expertise of most skilled participant

• Make it right?
• Can increase by collaboration

• Make it right?
• Two novices don’t produce the quality of
experts by pairing

• Make it right?
• Two novices don’t produce the quality of
experts by pairing
Two novices don’t
produce the quality of
experts by pairing!

Getting Past Advanced Beginner 
“Proficient practitioners can take full
advantage of the reflection and feedback
that is core to agile methods.”* 
But how do you get there?
- Individual exercise?
- Team work?
*Pragmatic Thinking & Learning,
Andrew Hunt, p.35

Acceptable Methods to Ensure
Quality Code and Coders
Pair Programming
Opportunistic Pairing
Pair Refactoring/Rewriting
Synchronous pull requests
Asynchronous pull requests
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication

Hot Communication & 
High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
* http://www.martinbauer.com/Articles/Open-Project-Management/Communication  
Alistair Cockburn, “Agile Software Development”, Addison-Wesley 2002

High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
Information
absorption  
Visual—65%  
Auditory—30% 
Kinesthetic—5%

High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
Information
absorption  
Visual—65%  
Auditory—30% 
Kinesthetic—5%
Feedback 
Loop

High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
Information
absorption  
Visual—65%  
Auditory—30% 
Kinesthetic—5%
Feedback 
Loop
Reading
code

High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
Information
absorption  
Visual—65%  
Auditory—30% 
Kinesthetic—5%
Feedback 
Loop
2 people on
email
Reading
code

High Skill Transfer
Pair Programming
Hot 
Communication
High Skill
Transfer
Low Skill
Transfer
Cold 
Communication
Information
absorption  
Visual—65%  
Auditory—30% 
Kinesthetic—5%
Feedback 
Loop
Code out
loud!
2 people on
email
Reading
code

Novice
Adv. Beg
Competent
Proﬁcient
Expert
Example 
Weak 
Professional
Developer 
Skill 
Scorecard

Novice
Adv. Beg
Competent
Proﬁcient
Expert
Clean Code,
TDD, and 
OO Thinking 
moves toward 
the “most 
skilled” at a 
rate you can 
adjust
Language 
Idioms and  
strengths/ 
weaknesses 
get shared 
among
the
team
More skills
are 
picked up by 
including 
specialists 
in process and 
observing 
“tips and
tricks”

“Have cheap people do easy things under the CLOSE
supervision of someone who knows the difference”
- Ken Auer, 2010 SCNA talk “Lean Craftsmanship vs. Corporate Craftsmanship”
“Have advanced beginners do tasks for which the rules
they know are appropriate to the context and check their
work. Let them watch, and have discussions with,
someone who has the appropriate skills for the task
when the advanced beginner does not”
- Ken Auer, 2013 SCNA talk “Craftsmen Cannot Live on Stack Overﬂow and Github Alone”
To a Novice, an Advanced
Beginner looks like an Expert

Craftsmanship Levels*
* http://bit.ly/29bHHU9

Craftsmanship Levels*
* http://bit.ly/29bHHU9
Wisdom
Knowledge

Longevity
Novice
Adv. Beginner
Competent
Proficient
Expert
EASYMED.HARD
EASYMED.HARD
EASYMED.HARD
Effectively
Troubleshoot
and correct
Production
Support
Challenges
Solidly Deliver
on Well-Defined
Tasks on Simple
Projects or
subsets of Non-
trivial Projects
Solidly Deliver
on Well-Defined
Tasks on Non-
trivial to
Complex
Projects
Hitting the Target w/ Software
Developers

Complexity
Longevity
Novice
Adv. Beginner
Competent
Proficient
Expert
EASYMED.HARD
EASYMED.HARD
Turn Clear
Requested
Features into
Well-defined
Tasks
Turn Ill-defined
Features into
Prioritized  
Well-defined
tasks
Developers

Longevity
Novice
Adv. Beginner
Competent
Proﬁcient
Expert
EASYMED.HARD
EASYMED.HARD
Identify and
Manage Inherent
Complexity of
Technical
Challenges and
Avoid Introducing
Complexity
Identify Inherent
Complexity of
Project/Customer
Challenges and
Avoid Introducing
Complexity or
Further Challenges
Complexity
Developers

Basic Rules for Building
Software Assets
Take this home with you… assess your team and tasks and how you are going about
managing inherent complexity and avoiding/reducing introduced complexity

Software Assets
• The Ratio of Experts-Novices should
change based on the nature of the project

Software Assets
• The Craftsmen-in-charge should oversee

Software Assets
• Very productive development
environment

Software Assets
environment
• What tasks get done by which people

Software Assets
environment
• What tasks get done by which people
• What form(s) of “two sets of eyes” is
appropriate in what contexts

Complexity
Longevity
Beneﬁts of Agility + Expertise

Complexity
Longevity
Beneﬁts of Agility + Expertise 
Trivial Tasks
anyone can do
with Async Pull
Request

Complexity
Longevity
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
designer(s) with little
code review but
signiﬁcant stakeholder
review

Complexity
Longevity
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
proﬁcient dev with
customer rep
feedback

Complexity
Longevity
New Feature
Walking
Skeleton: built in
test-driven fashion
by proﬁcient dev
with pair
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
customer rep
feedback

Complexity
Longevity
Fleshing Out
New Feature  
can be done by
less experienced
test-driven pairs
New Feature
Walking
Skeleton: built in
test-driven fashion
by proﬁcient dev
with pair
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
customer rep
feedback

Complexity
Longevity
Standards and
Architecture
designed/enforced
by Craftsmen
Fleshing Out
New Feature  
can be done by
less experienced
test-driven pairs
New Feature
Walking
Skeleton: built in
test-driven fashion
by proﬁcient dev
with pair
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
customer rep
feedback

Complexity
Longevity
Standards and
Architecture
designed/enforced
by Craftsmen
Fleshing Out
New Feature  
can be done by
less experienced
test-driven pairs
New Feature
Walking
Skeleton: built in
test-driven fashion
by proﬁcient dev
with pair
Debt Reduction 
identiﬁed,
prioritized, and
attacked by
experienced pairs
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
customer rep
feedback

Complexity
Longevity
Standards and
Architecture
designed/enforced
by Craftsmen
Fleshing Out
New Feature  
can be done by
less experienced
test-driven pairs
New Feature
Walking
Skeleton: built in
test-driven fashion
by proficient dev
with pair
Well-defined
Maintenance Tasks
can be done by
“anyone” who has
learned in context
Debt Reduction 
identified,
prioritized, and
attacked by
experienced pairs
Trivial Tasks
anyone can do
with Async Pull
Request
Prototype needs
highly skilled dev/
code review but
review
“Spiking” a
New Feature
typically needs
customer rep
feedback

Software Craftsmen
Take this home with you… assess yourself and tasks and how you are going about giving
and gaining wisdom. Geeks who know that people matter are the smartest geeks.

Software Craftsmen
• Seek Hot Communication and High Skill
Transfer situations for yourself and others

Software Craftsmen
• Be Hungry, Humble, and Smart

Software Craftsmen
“Knowledge makes arrogant, but love
ediﬁes. If anyone supposes that he
knows anything, he has not yet known
as he ought to know”(1 Corinthians 8:1b-2a, NASB)

Software Craftsmen
“Knowledge makes arrogant, but love
ediﬁes. If anyone supposes that he
knows anything, he has not yet known
as he ought to know”(1 Corinthians 8:1b-2a, NASB)
“When pride comes, then comes
dishonor, But with the humble is
wisdom.”(Proverbs 11:2, NASB)

Slides & References 
• slides available at: http://www.slideshare.net/kauerrolemodel/the-
relationship-between-agility-and-expertise
• Dreyfus Model of Skill Acquisition
• http://en.wikipedia.org/wiki/Dreyfus_model_of_skill_acquisition
• http://1.usa.gov/1iOLuWC - Dreyfus, Stuart E.; Dreyfus,
Hubert L. (February 1980), A Five-Stage Model of the Mental
Activities Involved in Directed Skill Acquisition
• http://bit.ly/1fU3aLn - Benner, Patricia (2004),  
Using the Dreyfus Model of Skill Acquisition to Describe and
Interpret Skill Acquisition and Clinical Judgment in Nursing
Practice and Education
• RoleModel’s Craftsmanship Levels: http://bit.ly/29bHHU9

CocoaConf Relationship Between Agility and Expertise

Recommandé

Recommandé

Contenu connexe

Similaire à CocoaConf Relationship Between Agility and Expertise

Similaire à CocoaConf Relationship Between Agility and Expertise (20)

Dernier

Dernier (20)

CocoaConf Relationship Between Agility and Expertise