sea side software engineering annotations l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
SEA Side Software Engineering Annotations PowerPoint Presentation
Download Presentation
SEA Side Software Engineering Annotations

Loading in 2 Seconds...

play fullscreen
1 / 30

SEA Side Software Engineering Annotations - PowerPoint PPT Presentation


  • 295 Views
  • Uploaded on

SEA Side Software Engineering Annotations Annotation 1: Extreme Programming Professor Sara Stoecklin Director of Software Engineering- Panama City sstoecklin@mail.pc.fsu.edu stoeckli@cs.fsu.edu 850-522-2091 850-522-2023 Ex 182 Florida State University Computer Science

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'SEA Side Software Engineering Annotations' - DoraAna


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
sea side software engineering annotations

SEA Side Software Engineering Annotations

Annotation 1: Extreme Programming

Professor Sara Stoecklin

Director of Software Engineering- Panama City

sstoecklin@mail.pc.fsu.edu

stoeckli@cs.fsu.edu

850-522-2091

850-522-2023 Ex 182

Florida State University

Computer Science

extreme programming
Extreme Programming
  • Definition:
    • An agile (lightweight) team process to create software rapidly that is extremely reliable, efficient, and well-factored. - (marketing)
    • A deliberate and disciplined approach to software development that emphasizes team work to improve the process through utilization of refactoring, patterns, and good testing.
extreme programming xp
Extreme Programming (XP)
  • History:
    • Many of the practices were created and tested as part of the Chrysler C3 project, which was a very successful software development project for a payroll system.
    • About six years old and has proved to be a cost effective process for development of software.
why not xp
Why Not XP
  • Lightweight – does not scale
    • Meant for small projects 2-15 people, 1 to 2 years. Most are less than 6 people and less than one year projects.
  • Not academically Proven
    • Statistics and successes are not tested by an independent group. Lot of hype.
  • Easy systems
    • Anyone can develop a small system what about a 5 year system with 300 database tables, 500 screens, 4000 reports and 1500 transactions. What about an operating system such as MVS or Windows XP?
why xp
Why XP
  • Promotes Good Software Engineering Principles
    • Patterns, refactoring, cohesion, coupling, encapsulation, polymorphism, and inheritance.
  • Allows the personal software process to mature
    • Allows a finely tuned software development process to emerge within an organization.
  • Promotes Good Testing Principles
    • Defines a method for testing, promotes testing as completely, encourages good unit testing.
what are the xp practices
What are the XP Practices
  • There are 12 simple practices which rely on the synergy between them. These practices support each other by covering the weakness of one with the strength of others
  • Five are basic XP principles
  • Seven are process techniques
twelve xp practices
Twelve XP Practices
  • Five Basic XP Principles
    • Small Releases
    • 40-hour work week
    • On-site customer
    • Collective Ownership
    • Coding Standards
twelve xp practices8
Twelve XP Practices
  • Five Basic XP Principles
    • Small Releases
      • Everything released to the customer should be as small as possible
      • Put simple system to work as quickly as possible
      • Release new versions on a very short development cycle
      • Helps to reduce schedule slips since short release cycles limit scope for each release
      • Release planning meeting discover these small units of functional behavior.
twelve xp practices9
Twelve XP Practices
  • Five Basic XP Principles
    • 40-hour work week
      • Never work overtime, go home at 5:00, have a nice week-end
      • Rested programmers have more courage and make fewer mistakes
      • Rested staff keeps them happy causing more chance of having stable teams.
      • Rested staff more able to handle intense inter-personal interaction of the team
      • Use the release planning meeting to plan the 40 hour week releases
twelve xp practices10
Twelve XP Practices
  • Five Basic XP Principles
    • On-site customer
      • A real customer is available on site.
      • Answers questions, resolve disputes, set small scale priorities, and provide test .
      • Customer participates in release planning meetings to define the small incremental RELEASES.
      • Customer participates in writing USER STORIES
      • Customer participates in testing RELEASES with the USER STORIES
twelve xp practices11
Twelve XP Practices
  • Five Basic XP Principles
    • Collective Ownership
      • Anyone can change the code and anyone who sees an opportunity to add value to any portion of the code is required to do it at any time.
      • Everyone improves product
      • Fix bugs – define tests to test bugs
      • Refactor Mercilessly
      • Create unit test for each unit developed
      • Frequent integration of new code
twelve xp practices12
Twelve XP Practices
  • Five Basic XP Principles
    • Coding Standards
      • Everybody defines the class naming standards, variable naming standards, class names, variable names.
      • Standards are set or evolve for the team.
twelve xp practices13
Twelve XP Practices
  • Seven Process Techniques
    • The Planning Game
    • Metaphor
    • Simple Design
    • Pair Programming
    • Refactoring
    • Continuous Integration
    • Testing
twelve xp practices14
Twelve XP Practices
  • Seven Process Techniques
    • The Planning Game
      • Customer and Developer participate in writing USER STORIES (other names - lightweight use cases, process narratives, scenarios). CRC cards helpful.
      • Each story transforms into one or more releases on a release plan.
      • Customer and Developer write, estimate stories, schedule by priority or risk with the team owning the schedule.
      • If the project velocity gets too high then we limit the scope of this release. If the load factor of a story gets to high then we split the story.
      • Customer writes the acceptance test cases for these USER STORIES
twelve xp practices15
Twelve XP Practices
  • Seven Process Techniques
    • Metaphor
      • Start development with just a metaphor not a detailed architectural plan
      • Be consistant with names, find common ground, find common domain patterns, solutions
      • Uniformity simplifies coding.
twelve xp practices16
Twelve XP Practices
  • Seven Process Techniques
    • Simple Design
      • The right design for the system at any moment is the one that had not duplication, runs all the tests, does everything needed, upholds constraints.
      • Start with small simple designs
      • A simple design takes less time to finish than a complex one.
      • Never add functinality before it is scheduled.
      • Simple designs are easier to maintain.
      • Refactor out complexity
      • Do spike solutions (risk first)
twelve xp practices17
Twelve XP Practices
  • Seven Process Techniques
    • Pair Programming
      • Master feedback loop to ensure that the XP programming practices stay in place.
      • Reduces overall project risk.
      • Two people working side by side to produce quality code – one thinks, one drives.
twelve xp practices18
Twelve XP Practices
  • Seven Process Techniques
    • Pair Programming
      • Thinker
        • Is this approach going to work
        • What are some test cases to test this code
        • Is there some way to simplify the code
        • Is there some pattern we should be using
        • Is there duplicated code
        • Is there some refactoring technique to use
        • Is there some other solution
      • Driver
        • Keys in solutions
        • Aids thinker
twelve xp practices19
Twelve XP Practices
  • Seven Process Techniques
    • Pair Programming
      • Does not cost twice as much.
        • Aids in jelling programming assignment
        • Encourages testing
        • Encourages thinking
        • Encourages not leaving bad code
      • Pair new programmer with old-timer.
      • Rules:
        • can’t go off and do things separately
        • Both must be able to see the monitor
        • Take turns driving
        • No lone rangers
        • Trust your partner
twelve xp practices20
Twelve XP Practices
  • Seven Process Techniques
    • Refactoring
      • Remove duplication
      • Improve communications
      • Add flexibility
      • Simplify
      • Refactor for patterns (design, application, analysis)
      • Refactor for good design
      • Keep code clean
twelve xp practices21
Twelve XP Practices
  • Seven Process Techniques
    • Continuous Integration
      • Build, integrate and test daily according to the iteration planning and release scheduling
        • Load current release
        • Load changes
        • Run tests
      • Take iteration deadlines seriously
      • Measure progress with standup meetings
twelve xp practices22
Twelve XP Practices
  • Seven Process Techniques
    • Testing
      • Types
        • Functional testing – black box
        • Unit tests – programmer written with method by method
        • Acceptance tests - customer written for stories
        • Parallel tests – test to assure system works as old system
        • Stress test – simulate worst case load
        • Monkey test – test behavior of nonsensical input
twelve xp practices23
Twelve XP Practices
  • Seven Process Techniques
    • Testing
      • Unit tests
        • Cornerstone of XP – code it first
        • Need a unit test framework
          • http: www.XProgramming.com
        • Harder it is to write the test- more you need it
        • Enables collective code ownership
        • Junit testing becoming standard
        • Enables refactoring and frequent integration
        • Safety net of regression and validation tests
twelve xp practices24
Twelve XP Practices
  • Seven Process Techniques
    • Testing
      • Unit tests
        • Rhythm for unit testing
        • Loop iteratively
          • Write a little code
          • Write the code for testing this code
          • Test written code with code for testing
          • Correct code or test for code
twelve xp practices25
Twelve XP Practices
  • Seven Process Techniques
    • Testing
      • Acceptance Tests
        • Created from user stories
        • Black box system tests
        • Used in regression tests
        • Should be automated so they can be ran often
        • Improve the quality of the system
the xp process

Defines user requirements

The XP Process

requirements

bugs

Build User Stories

new velocity

Conduct Release Planning

Build Iteration

Conduct Acceptance Testing

release

metaphor

release plan

Define Architectural Spikes

estimating

next iteration

Controls Scope

Improves

Quality

getting started
Getting Started
  • How do I start using XP
    • A new project
    • Collect user stories
    • Conduct spike solutions
    • Schedule release planning meeting
    • Plan iterations
    • Start iterative development
    • Try automated unit tests
    • Try automated acceptance testing
web sites
Web-Sites
  • http://www.extremeprogramming.org
  • http://www.junit.org
  • http://www.instantiations.com/jfactor/
  • http://c2.com/cgi/wiki?ExtremeProgrammingRoadmap
  • http://www.xpuniverse.com/home
summary
Summary
  • Remember – XP is lightweight – does not scale
    • Meant for small projects 2-15 people, 1 to 2 years. Most are less than 6 people and less than one year projects.
  • Promotes Good Software Engineering Principles
    • Patterns, refactoring, cohesion, coupling, encapsulation, polymorphism, and inheritance.
  • Allows the personal software process to mature
    • Allows a finely tuned software development process to emerge within an organization.
  • Promotes Good Testing Principles
    • Defines a method for testing, promotes testing as completely, encourages good unit testing.
slide30

Computing Degrees at FSU-Panama City

Information System Degrees

Scientific Degrees

Computer Science (MS, Web-BS)

Management Information Systems (BS)

. Advisor Jeanne Dexter – jdexter@mail.pc.fsu.edu

. Advisor Sara Stoecklin stoeckli@cs.fsu.edu

  • Systems Analysis
  • IT Management
  • Computer Consulting
  • Application Programming
  • Operating Systems
  • Systems Programming
  • Applications Programming
  • Database Administration
  • Systems Administration

Math&Science

Business

General

Math&EE

Information Studies (Web – BS,MS)

Computer Engineering (BS, Web-MS)

. Advisor Alan Stromberg sdytomnrty@mail.pc.fsu.edu

. Advisor Kamran Imen kimen@mail.pc.fsu.edu

  • Embedded Systems
  • Image Processing
  • Electronics and Electromagnetics
  • Signals and Systems
  • Communications
  • Microprocessors
  • Computer Architecture
  • Web Development
  • Network Management
  • Information Systems
  • Management of Information Services
  • Social Informatics
  • Information and Communication Technologies

. Degree Programs http://www.pc.fsu.edu/degreeplansheets/default.asp