Padawan to Jedi Developer Jump-Start

http://chrisedwards.dreamhosters.com

Follow @ChrisEdwards357 or #Padawan2Jedi for tweet stream of resources

Padawan to Jedi
A Developer Jump-Start
A U S T I N - C O D E - C A M P - 2 0 1 1

Chris Edwards



About Me
Chris Edwards
Architect at BancVue
Ltd.
Email: ChrisEdwards357@gmail.com
Blog: http://
chrisedwards.dreamhosters.com
Twitter: @ChrisEdwards357
Github: http://github.com/
chrisedwards



About Me
Chris Edwards
Ltd.
Blog: http://
Twitter: @ChrisEdwards357
Github: http://github.com/
chrisedwards

We are hiring!



What makes a great developer?



Passion



Continuous
Learning



Read
Books
Continuous
Learning



Read
Books
Continuous
Learning
ad
Re s
Blog


Follow
Others

Read
Books
Continuous
Learning
ad
Re s
Blog


Fiesta
! de Camp
Co A
ustin
Attend
A ustin
User
.NET
Grou
Follow
p
Events
Others

Read
Books
Continuous
Learning
ad
Re s
Blog


Humility



Communication Skills



Basics Beginning with the basics...



Basic oo concepts



Basic oo concepts
(Object Oriented)



Encapsulatio



Encapsulatio

Information Hiding


Polymorphis



Low Coupling / High Cohesion



Communicating via uML



Class Diagram



Sequence Diagram



Activity Diagram



Design
The theory and Practice of Design...



What makes great software...



Functionality (It
works!)



Maintainabilit
y



Redundanc
y



Scalability



Performance



Usability



Design Principles
The theory and Practice of Design...



Keep
It
Super
Simple



You
A ren’t
G on na
N eed
It



Last Responsible
Moment


Avoid Premature
Optimization


Don’t
Repeat
Yourself



Separation of
Concerns



Composition
over
Inheritance



Explicit
over
Implicit



Fail Fast



Law of
Demeter



No Broken Windows



The Boy Scout Rule



The Solid Principles
Principles for SOLID code



SRP Responsibility
The Single
Principle



ocp Open-Closed
The
Principle



lsp Liskov Substitution
The
Principle



ispInterface Segregation
The
Principle



dipDependency Inversion
The
Principle



SOLID Motivational Posters



Design Patterns
Testing with mocks and stubs.



First, a word of



gang of four patterns



Creational Patterns
Abstract
Factory Structural
Builder Adapter
Factory Method Bridge
Prototype Composite
Singleton Decorator
Facade
Flyweight
Proxy


Behavioral
Chain of Memento
Responsibility Observer
Interpreter State
Iterator Strategy
Mediator Template Method



PoEAA patterns



other design patterns

GRASP
Martin Fowler’s Pattern



Domain Driven Design



Building
Entity
Value Object
Aggregate Root Patterns
Service Ubiquitous Language
Repository Bounded Context
Factory Continuous
Integration
Many More...



Pattern Relationship
Map



refactoring changing form while preserving function

(Changing form while preserving function.)



Resources

http://www.refactoring.com



Code Smells



ReSharper



Persistence changing form while preserving function



Persistence Ignorance



Repository and
Unit of Work Patterns



Object Relational Mappers

NHibernate
Entity Framework
Etc.



TESTiNG



Types of Tests



Types of Tests

Unit Tests



Types of Tests

Unit Tests

Integration Tests



Types of Tests

Unit Tests

Integration Tests
Functional / UI
Tests


Agile Testing quadrants



Test Automation Pyramid



unit testing



Good Unit Tests Are...

Atomic Easy to Set Up
Self-Contained Fast
Order- Repeatable
Independent Readable (Clear)
Meaningful Unique



Test-Driven Development



TDD



uncle bob’s
Three Rules of

1. You can write no production code
unless it makes a failing test pass.

2. You can write no more test code than
is sufficient to fail.

3. You can write no more production
code than is necessary to pass the


Red...Green...Refactor
The Heartbeat of

RED Write a failing unit test. See
Green it fail. the test pass.
Make
Refactor Clean up implementation
based on what you have



.NET Unit Testing
•NUnit
•MSpec (Machine.Specifications)
•MSTest



A Basic Unit Test using
[TestFixture]
public class OrderTests
{
[Test]
public void TestCalculateSubTotal()
{
var order = new Order();
order.AddLineItem("Star Destroyer", 5000.00);
order.AddLineItem("Death Star", 10000.00);

double subTotal = order.CalculateSubTotal();

Assert.That( subTotal, Is.EqualTo( 15000.00 ) ); }
}



public class Order
{
public int Id { get; set; }
public Customer Customer { get; set; }
public DateTime OrderDate { get; set; }
public IList< LineItem > LineItems { get; set; }

public double CalculateSubTotal()
{
return LineItems.Select( x => x.Price ).Sum();
}

public void AddLineItem( string description, double price )
{
LineItems.Add( new LineItem( 1, description, price ) );
}
}



AAA
Arrange, Act,
Assert



[Test]
{


Assert.That( subTotal, Is.EqualTo( 15000.00 ) );
}



[Test]
{


}

[ Test ]
{
// Arrange.

// Act

// Assert.
}



Unit Test with



Unit Test with
[ TestFixture ]
{
Order _order;

[ SetUp ]
public void SetUp()
{
// Arrange.
_order = new Order();
_order.AddLineItem( "Star Destroyer", 5000.00 );
_order.AddLineItem( "Death Star", 10000.00 );
}

[ Test ]
public void TestCalculateSubtotal()
{
// Act.
double subTotal = _order.CalculateSubTotal();

// Assert.
}
}



BDD Driven
Behavior
Development



[ TestFixture ]
{
Order _order;

[ SetUp ]
public void SetUp()
{
// Arrange.
}

[ Test ]
public void TestCalculateSubtotal()
{
// Act.
double subTotal = _order.CalculateSubTotal();

// Assert.
}
}



[ TestFixture ]
public class When_an_order_has_two_line_items
{
Order _order;

[ SetUp ]
public void SetUpContext()
{
}

[ Test ]
public void Calculating_the_subtotal_should_return_the_sum_of_the_line_item_prices()
{
Assert.That( _order.CalculateSubTotal(), Is.EqualTo( 15000.00 ) );
}
}



A BDD-Style Test using
[ Subject("Order") ]
public class When_an_order_has_two_line_items
{
static Order _order;
static double _subTotal;

Establish context = () =>
{
};

Because of = () => _subTotal = _order.CalculateSubTotal();

It should_calculate_the_subtotal_of_line_items = () => _subTotal.ShouldEqual( 15000.00 );
}



[ Subject( "Order" ) ]
public class Given_an_order_with_two_line_items
{
protected static Order _order;

Establish context = () =>
{
};
}

public class When_calculating_the_subtotal : Given_an_order_with_two_line_items
{
static double _subTotal;

Because of = () => _subTotal = _order.CalculateSubTotal();
It should_equal_the_sum_of_the_line_item_prices = () => _subTotal.ShouldEqual( 15000.00 );
}

public class When_removing_a_line_item_by_its_description : Given_an_order_with_two_line_items
{
Because of = () => _order.RemoveLineItem( "Star Destroyer" );
It should_remove_the_line_item_from_the_order = () =>
_order.LineItems.Any( x => x.Description == "Star Destroyer" ).ShouldBeFalse();
}



Tests are documentation
Given an order with two line items:

When calculating the subtotal
It should be the sum of the line
item prices.

When removing a line item by its
description


Context: Given an order with two line items:

Specificati When calculating the subtotal
on: It should be the sum of the line
item prices.
Specificati
on: When removing a line item by its
description


Arrange Given an order with two line items:
:
When calculating the subtotal
It should be the sum of the line
item prices.
Act:
Assert: When removing a line item by its
description


Acceptance Test Driven
Development (ATDD)
Specification By Example



More Resources for TDD
Bowling Game Kata
James Shore “Let’s Play TDD” video
series.



Mocking



Rhino Mocks



State-based vs. Interaction-



inversion of control



inversion of control (IoC)



Tools (IoC
Structure Map
Ninject
Autofac



Code



Code Coverage Tools

TestDriven.NET
dotCover
(JetBrains)
NCover
NCrunch



Source control



Standard
Subversion
CVS
Others



Standard
Subversion
CVS
Others

Distributed
Git
Mercurial



continuous
integration



TeamCity



Build Monitor



Continuous
Deployment



Agile
(Embrace Change)


Agile embrace change!
(Embrace Change)


the Agile manifesto
We are uncovering better ways of
developing software by doing it and
helping others do it.
Through this work we have come to value:
Individuals &
over Processes & Tools
Interactions Comprehensive
Working Software over
Customer Documentation
over Contract Negotiation
Collaboration
Responding to Change over Following a Plan
That is, while there is value in the items
on the right, we value the items on the
left more.


Many Methodologies

Extreme Programming
(XP)
Scrum


Extreme Programming (xp)
Values:
Communicati
on
Feedback Practices:
Simplicity Stand Up Meeting
Courage Collective Code
Ownership
Pair Programming
Planning Game
(TDD)
Whole Team
Continuous Integration (CI)
Merciless Refactoring
Small Releases
Coding Standards
Simple Design
System Metaphor
Sustainable Pace

Scrum 3 Roles:
Product Owner
ScrumMaster
Team

4 Ceremonies:
Sprint Planning
Daily Scrum
Sprint Reviews
Sprint
Retrospectives
3 Artifacts:
Product Backlog
Sprint Backlog
Burndown


Agile Practices A walk through the process
(A walk through the process)



Short Iterations &
Feedback Loops

Frequency promotes
Efficiency


User Stories



Backlog



Planning Game



Sustainable Pace /
Velocity



Sustainable Pace /
Velocity

Looking at yesterday’s
weather


Self-Organizing
Team



Collective Code
Ownership



Collective Code
Ownership

“Mine Mine”



Pair
Programming



Merciless
Refactoring



Stand Up Meeting



Information Radiators

Burndown Chart Task Board

Build Monitors


Sprint Demo

Demonstration is better than
Discussion


Feedback

Firing tracer bullets


Retrospectives



Automation

Automate everything you can!


Don’t be discouraged!



Don’t be discouraged!

Everyone has to start somewhere.


About Me
Chris Edwards
Ltd.
Blog: http://



About Me
Chris Edwards
Ltd.
Blog: http://

We are hiring!



Padawan to Jedi Developer Jump-Start

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

Padawan to Jedi Developer Jump-Start

Editor's Notes