Melissa Nava - web design - border top. Melissa Nava - graphic design - border top.    
Melissa Nava Consulting - custom graphics - logo. Melissa Nava - graphic art - upper background in blue and black.
Melissa Nava - specializes in online artwork - top border bottom.
spacer
Home | Calendar | Contact | Forum | News | Portfolio | Services | Prices

System Development - Extreme Programming!

Extreme Programming is an evolving methodology that was created by an Object Oriented developer by the name of Kent Beck. In the simplest form, Extreme Programming development is a methodology that is based on simplicity, communication and feedback. Extreme programming is based around the customer of the system, this person works with the development team during the whole development process.

Extreme Programming works becase it brings the entire development team together, as a group the development team follows a set of simple practices that encourage feedback so that the entire group can work forward on their particular project together. One of the biggest problems in software development is scope creep. Almost all IT programmers, designers, project managers are familiar with how scope creep works and sneaks up on a project. With Extreme Programming, scope is watched very carefully.

With Extreme Programming there are small releases of code that are produced along the way to the final project development. This means that management or the customer can choose what features that they want or need with different releases of the software. With each release of the software, the project is completed, tested and approved. This allows the customer to fine tune the project along the way, adjust the project accordingly. Even though you are watching scope, this development methodology, Extreme Programming, allows the scope to adjust along the way to the project development.

Extreme Programming relies heavily on the development team, management and the customer collaborating together and communicating. This type of programming methodology allows programmers and developers to work in groups. This allows for prorammers to correlate with each other and work rapidly.

In fact in many Extreme Programming scenarios you would find a group of programmers working on a project; walk into a room and find two programmers sitting at each computer, correlating together working together coding and solving the problems collaborating together and working faster. Extreme Programming allows programmers to get constant feedback from managers and the customers of the project, this allows the programmers to program what is needed as it is needed rather than spending time up-front trying to design a system and then realizing into the project that the original scope of the project is not really what was needed, and then have to plan again to change the scope. Extreme Programming allows the scope of the project to change accordingly with the project along the way, allowing the programmers to do what they do best, program.

In the most simple of forms, Extreme Programmers follows this cycle:

Plan > Code > Test > Plan > Code > Test

There are 12 basic rules of Extreme Programming, they are:

  • Planning:
    Programmers, managers, and customers meet each week to plan and schedule upcoming tasks for the upcoming week;
  • Code Releases:
    Small system releases, very short release cycles;
  • Metaphor:
    You should create an analogy that helps to express how the parts of the system will work;
  • Simple Design:
    Make sure that the design of the system is simple, any complexities should be removed as you go along with the development;
  • Testing:
    As you develop the program make sure that the system is fully tested along the way. This helps to make sure that there are no problems with the system as you develop it;
  • Refactoring:
    Write the code in the simplest form, make the code simple, flexible and not redundant;
  • Pair Programming:
    All code that is written in the application will be written by two programmers at each machine.
  • Collective Ownership:
    All programmers in the application can program any part of the application, remove code from anywhere in the application, and update and fix code anywhere in the application. All programmers take ownership of the code;
  • Continuous Integration:
    All peices of the application should be integrated with each other often, this will make sure that even though this is a growing project, that all of the pieces of the application work together;
  • 40 Hour Work Week:
    Programmers and people on the development team don't work more than 40-hour weeks. If one has to work overtime, they will not work any overtime for more than one week in a row;
  • Onsite Customer:
    There will always be an onsite customer to answer questions from the development team;
  • Coding Standards:
    Programmers will use coding standards so that the different programmers, who are sharing the code ownership, can easily tell what things are doing as well as everyone coding in the same style.

Copyright © 2007
Melissa Nava Consulting
http://www.melissanava.com

If you wish to reproduce any information on this website, please contact Melissa Nava Consulting for permission.

Continue reading about the Systems Development Lifecycle processes.

Search Melissa Nava Consulting
 

 

Melissa Nava Website Design - page border bottom.
© 2000 - 2007 Melissa Nava
Hosted by CrystalTech