Seven Pillars

(c)agile skills project

Comienza Ya. Es Gratis
ó regístrate con tu dirección de correo electrónico
Rocket clouds
Seven Pillars por Mind Map: Seven Pillars

1. Static Code Analysis Tools

1.1. Find Bugs Report

1.2. Cyclomatic Complexity

2. Database Refactoring

2.1. testing databases

2.2. abstracting away from dbms

3. customer satisfaction

3.1. split testing

4. Bugs

5. Relational vs Hierarchical Thinking

6. Performance / Response Time

7. Non-functional requirements

7.1. Load / Capacity

7.2. Robustness / Long Duration

8. Critiquing the Product

8.1. Test Harness for Legacy Code

8.1.1. test seams

8.1.2. dependency breaking

8.1.3. sprouts and strangling

9. easy to use/learn

9.1. simple

9.2. functional completeness

9.3. overall coherence

9.3.1. Evolutionary Design

10. Domain-Driven Design

11. Persistent

12. JDUF-just enough design up front

13. Code Smells

13.1. Don't Repeat Yourself

13.2. Law of Demeter (Tell Don't Ask)

13.3. Metrics

13.3.1. Test Coverage

13.3.2. Lines of Code (sphags)

14. Collaboration

14.1. Sufficient communication

14.2. Frequent

15. Business Value

15.1. validating

15.1.1. Release Management

15.1.1.1. Flow

15.1.1.2. Stories

15.1.1.2.1. Story Estimation

15.1.1.2.2. Story Splitting

15.1.1.2.3. Story Writing

15.1.1.3. Delivering In Small Slices

15.1.1.3.1. Incremental

15.1.1.3.2. Iterative

15.1.1.4. Product Backlog

15.1.1.4.1. Sprint Backlog

15.1.1.5. frequent delivery

15.1.1.6. Basic Throughput Accounting

15.1.1.6.1. Cadence

15.1.1.6.2. Limiting Work in Progress

15.1.1.6.3. Optimize the whole

15.1.1.6.4. Value Stream Mapping

15.1.1.7. Kanban

15.1.2. Time management

15.1.2.1. Pomodoro

15.1.2.2. Getting Things Done

15.1.2.3. Timeboxes

15.2. avoiding waste (muda)

15.2.1. Extra features

15.2.2. Heavy specs

15.2.3. Handoffs

15.2.4. Waiting

15.2.5. Multi-step analyze-dev-test-verify...

15.2.6. Re-creating knowledge

16. Supportive Culture

16.1. Conflict management

16.1.1. diagnosis

16.1.1.1. dissapointment

16.1.1.2. friction

16.1.1.3. disconnect

16.1.1.4. disagreement

16.1.2. productive discussion

16.1.2.1. Consent-based decision making

16.1.2.2. Knowledge vs Information

16.1.2.3. Facilitation

16.2. respect

16.2.1. Craftsmanship Manifesto

16.2.2. Declaration of Interdependence

16.2.3. Agile Manifesto

16.2.4. growing trust

16.2.5. individuals and interactions over processes and tools

16.2.6. give teams what they need & trust them to get the job done

16.3. commitment

16.3.1. Nudging for Improvement

16.3.1.1. Jiggling (Change Agent)

16.3.2. Patrick Lencioni’s Five Dysfunctions of a team

16.3.2.1. Absence of Trust

16.3.2.2. Fear of Conflict

16.3.2.3. Lack of Commitment

16.3.2.4. Avoidance of Accountability

16.3.2.5. Inattention to Results

16.3.3. help

16.3.3.1. Knowing when you're blocked

16.3.3.2. Ask first, conclude later

16.3.3.3. Active Listening

16.3.3.4. Mentoring

16.3.3.5. Helping

16.3.4. whole team attitude

16.3.4.1. Cross-functional teams

16.3.4.2. generalizing specialists

16.3.4.3. product focus

16.3.4.4. responsibility

16.3.4.5. autonomy

16.3.5. permanent team attitude

16.3.5.1. improves productivity

16.3.5.2. enhances commitment

16.3.5.3. shared history

16.4. Space to learn

16.4.1. slack

16.4.2. accepting failure

16.4.3. sustainable pace

16.4.4. risk taking

17. Technical Excellence

17.1. Simple Design

17.1.1. KISS - Keep it simple, stupid!

17.1.1.1. Architecture--simplest thing that could possibly work

17.1.1.2. One level of abstraction

17.1.2. Design Patterns

17.1.2.1. Evolutionary Iterative Development

17.1.2.2. Emergent Design

17.1.2.2.1. Refactoring to Framework

17.1.2.2.2. Avoid Speculative Generality

17.1.2.3. MVP / MVC Patterns

17.1.2.4. Separation of Concerns

17.1.2.5. FCoI - Favour Composition over Inheritance

17.1.2.6. Modeling

17.1.2.6.1. CRC (class responsibility collaborator) cards

17.1.2.6.2. UML diagrams

17.1.2.6.3. whiteboard discussions

17.1.3. Craftsmanship

17.1.3.1. Clean Code

17.1.3.2. Boy Scout Rule

17.1.3.3. Source Code Conventions

17.2. Refactoring

17.2.1. SOLID

17.2.1.1. Single Responsibility Principle

17.2.1.1.1. Coding by Intention

17.2.1.2. Open Closed Principle

17.2.1.3. Liskov Substitution Principle

17.2.1.4. Interface Segregation Principle

17.2.1.5. Dependency Inversion Principle

17.2.2. Common Refactorings

17.2.2.1. Compose Method

17.2.2.2. Extract Method

17.2.2.3. Inline Method

17.2.2.4. Rename

17.2.3. Test Refactoring

17.2.4. Modular Design

17.3. Testing

17.3.1. developer tests

17.3.1.1. Unit Testing

17.3.1.1.1. xUnit

17.3.1.2. Design-for-Testability

17.3.2. test-first

17.3.2.1. Test-Driven Development

17.3.2.1.1. TDD Cycle - Red, Green, Refactor

17.3.2.1.2. Which test next?

17.3.2.1.3. TDD with GUIs

17.3.2.2. Tests Used for Design

17.3.2.3. Behavior-Driven Development

17.3.2.3.1. StoryTest-Driven Development

17.3.3. customer tests

17.3.3.1. Acceptance Testing

17.3.3.2. Exploratory Testing

17.3.3.3. Testing Quadrants

17.3.3.3.1. Supporting Programming

17.3.3.3.2. Robustness / Fault Tolerance

17.3.3.3.3. Technology Facing

17.3.3.3.4. Business Facing

17.3.4. Test Automation

17.3.4.1. Test Automation Patterns

17.3.4.1.1. Test Doubles

17.3.4.1.2. 3A Pattern: Arrange, Act, Assert

18. Self Improvement

18.1. intentional practice

18.1.1. book discussions

18.1.2. online communities

18.1.3. Reading

18.1.4. Code Kata

18.1.5. local user groups

18.1.6. open source projects

18.1.7. conferences

18.2. retroflection

18.2.1. Daily self reflection

18.2.2. Self Management

18.2.3. Common Pitfalls

18.2.4. Self Awareness

18.3. balance

18.3.1. Keeping Motivated

18.3.1.1. autonomy

18.3.1.2. mastery

18.3.1.3. purpose

18.3.2. work/ health/ friends

18.3.3. social captial (networking)

18.3.4. slack

19. Product

19.1. vision

19.1.1. clear problem domain

19.1.1.1. Visualization and Presentation Techniques

19.1.1.2. Wireframe/Paper Prototyping

19.1.1.3. working directly with whole team

19.1.2. explicit goals

19.1.2.1. managed scope

19.1.3. measured progress

19.1.3.1. success metrics

19.1.3.2. split testing

19.2. solves real/valuable problems

20. Confidence

20.1. Definition of Done

20.1.1. working software

20.1.2. validated learning

20.1.3. High Quality

20.1.3.1. Zero Bugs

20.2. Visibility

20.2.1. Storyboard

20.2.2. Informative Build

20.2.3. Burn-up/down charts

20.2.4. transparency

20.2.4.1. open decision making

20.2.4.2. continuous improvement

20.2.4.2.1. Plan Do Check Act

20.2.5. Reliable Cadence

20.2.6. Using Version Control

20.2.6.1. Distributed

20.2.6.2. Optimistic vs Pessimistic Locking

20.2.6.3. branching

20.2.7. Continuous Integration (CI)

20.2.7.1. CI Tools

20.2.7.2. automated deployment

20.2.7.3. automated build

20.2.7.3.1. ten-minute build

20.2.7.4. automated deployment

20.2.7.5. frequent check-in