The art of being an agile programmer
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

The art of being an agile programmer

on

  • 134 views

Programmers know good code. But in the context of today so competitive world of technology, this is not enough. We know this because good code has not saved us from doing overtime or getting bad ...

Programmers know good code. But in the context of today so competitive world of technology, this is not enough. We know this because good code has not saved us from doing overtime or getting bad performance reviews. What are we missing? We are forgetting about agile technical practices. In this presentation I am talking about how at MozaicWorks.com I have learned to use agile and XP technical practices for efficient quality product development.

Statistics

Views

Total Views
134
Views on SlideShare
134
Embed Views
0

Actions

Likes
1
Downloads
1
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

The art of being an agile programmer Presentation Transcript

  • 1. The art of being an agile programmer
  • 2. Claudia Rosu ● Software developer at mozaicworks.com ● 4 years experience in JEE development ● 3 years experience with Agile practices ● A girl working with the guys for making software development better
  • 3. Agenda ● True story ● The problems from the story ● Root cause analysis for first problem ● Technical practices to help us ● Agile programmer at work ● Joy of coding!
  • 4. What was wrong? ● Bugs discovered one day before ● Incomplete deployment instructions ● Incomplete features
  • 5. Root cause analysis
  • 6. How to attack this nasty situation? How can we know we are doing the right thing? How can we know we are doing the things right? Agile is about getting feedback as soon as possible in all phases of software development, not just when testing
  • 7. Understand
  • 8. Start with the User interface ● Build static html user interface according to mockup ● Validated it with the story owner
  • 9. Acceptance Tests ● write integration tests as acceptance tests using code and business like language ● they will ensure a common understanding of the story ● review them with a tester or/and the story owner ● the implemented solution is complete if it passes all acceptance tests
  • 10. Acceptance tests @Test void newPrescriptionFormIsOpened() { userOpesSubEncounter() userClicksOnWritePrescriptionActivity() assertNewPrescriptionFormIsOpened() } @Test void newPrescriptionIsCreatedWhenSaving() { userEntersPrescriptionData() userSavesPrescription() assertNewPrescriptionHasBeenCreated() }
  • 11. Design and implement ● design using code ● write unit tests as a practice to reflect upon the code ● first advantage: you will write the minimal necessary amount of code for the logic that needs to be implemented ● second advantage: you are already testing your code, so less testing after ● Third advantage: you are already receiving feedback that your solution does what it is supposed to do
  • 12. Refactoring ● Do this in order to polish the design ● Do it step by step ● Quite often, I have found bugs during refactoring ● Take 30 minutes or 1 hour to refactor old code also ● Include this always while implementing the story, not after
  • 13. Code review ● another check for bugs or flawed implementation ● a chance to do pair-programming, to learn from others
  • 14. Early testing ● Start testing from analysis phase ● Continue during implementation ● Minimize the work not done
  • 15. Automated tests ● sit back and watch how your automated tests are doing the manual testing for you ● they will also keep you away from entering regression bugs
  • 16. Agile programming analysis with acceptance tests and mockups testing with acceptance tests and unit tests design with unit tests implementation with code, refactoring and code review
  • 17. Agile programmer at work ● Use code to do analysis, design, implementation and testing ● Write readable and maintainable code and tests ● Strive for simplicity ● Work in small and safe increments ● Embrace change ● Be creative ● Communicate: give feedback and ask for feedback
  • 18. claudia.rosu@mozaicworks.com @claudia_rosu
  • 19. References http://mozaicworks.com/blog/5-tips-to-avoid-release-hell -as-scrum-master/ http://mozaicworks.com/blog/a-developer-in-test/ http://www.infoq.com/articles/atdd-from-the-trenches http://xprogramming.com/what-is-extreme-programming/