Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:32:03Z

Lee: /* Dynamic Systems Development Method (DSDM) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

Since this is not really a stand alone method in and of itself, it will not be discussed in great detail.

=== Agile Unified Process (AUP) ===

A simplified agile version of Rational Unified Process (RUP).

Composed of four phases:

* Inception - identify the scope of the project, a potential architecture, and get the initial resources and acceptance.
* Elaboration - Prove the architecture.
* Construction. Create functional software on an incremental time frame which completes the highest priority features as designated by the stakeholders.
* Transition - Deploy the new system to production and validate its effectiveness.

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

Also some of them introduce a daily status meeting while others do not. Overall it is somewhat difficult to spot too many differences between the methods.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.ambysoft.com/unifiedprocess/agileUP.html The Agile Unified Process]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:31:52Z

Lee: /* Major Differences */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

Since this is not really a stand alone method in and of itself, it will not be discussed in great detail.

=== Agile Unified Process (AUP) ===

A simplified agile version of Rational Unified Process (RUP).

Composed of four phases:

* Inception - identify the scope of the project, a potential architecture, and get the initial resources and acceptance.
* Elaboration - Prove the architecture.
* Construction. Create functional software on an incremental time frame which completes the highest priority features as designated by the stakeholders.
* Transition - Deploy the new system to production and validate its effectiveness.

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

Also some of them introduce a daily status meeting while others do not. Overall it is somewhat difficult to spot too many differences between the methods.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.ambysoft.com/unifiedprocess/agileUP.html The Agile Unified Process]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:30:43Z

Lee: /* Agile Modeling (AM) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

Since this is not really a stand alone method in and of itself, it will not be discussed in great detail.

=== Agile Unified Process (AUP) ===

A simplified agile version of Rational Unified Process (RUP).

Composed of four phases:

* Inception - identify the scope of the project, a potential architecture, and get the initial resources and acceptance.
* Elaboration - Prove the architecture.
* Construction. Create functional software on an incremental time frame which completes the highest priority features as designated by the stakeholders.
* Transition - Deploy the new system to production and validate its effectiveness.

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.ambysoft.com/unifiedprocess/agileUP.html The Agile Unified Process]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:30:19Z

Lee: /* Agile Unified Process (AUP) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

=== Agile Unified Process (AUP) ===

A simplified agile version of Rational Unified Process (RUP).

Composed of four phases:

* Inception - identify the scope of the project, a potential architecture, and get the initial resources and acceptance.
* Elaboration - Prove the architecture.
* Construction. Create functional software on an incremental time frame which completes the highest priority features as designated by the stakeholders.
* Transition - Deploy the new system to production and validate its effectiveness.

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.ambysoft.com/unifiedprocess/agileUP.html The Agile Unified Process]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:26:25Z

Lee: /* References */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

=== Agile Unified Process (AUP) ===

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.ambysoft.com/unifiedprocess/agileUP.html The Agile Unified Process]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:24:59Z

Lee: /* Major Differences */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

=== Agile Unified Process (AUP) ===

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:24:48Z

Lee: /* References */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

=== Agile Unified Process (AUP) ===

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]
* [http://www.agilemodeling.com/practices.htm Agile Modeling Practices]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:24:32Z

Lee: /* Agile Modeling (AM) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

=== Agile Unified Process (AUP) ===

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:16:12Z

Lee:

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
* Product Backlog - A collection of user stories that make up what can be added to a sprint.
* Sprint Backlog - The user stories that will be done during the sprint.
* Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

== Major Differences ==

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:15:25Z

Lee: /* Definitions */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
Product Backlog - A collection of user stories that make up what can be added to a sprint.
Sprint Backlog - The user stories that will be done during the sprint.
Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

== Major Differences ==
All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
* Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
* Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
* CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T22:11:36Z

Lee: /* Lean Software Development (LSD) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
Product Backlog - A collection of user stories that make up what can be added to a sprint.
Sprint Backlog - The user stories that will be done during the sprint.
Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===

This methodology consists of the following principles:

* Eliminate Waste - eliminate everything that is not adding value for the customer
* Amplify learning - Techniques to increase learning and improve the software
** Write tests as soon as code (to be tested) is written.
** Instead of detailed planning, code different techniques and try them out
* Decide as Last as possible - Decision should be delayed as long as possible
* Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
* Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
* Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
* See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

== Major Differences ==
All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
Chicken/Pig philosophy -
CRC Cards -

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:51:14Z

Lee: /* References */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
Product Backlog - A collection of user stories that make up what can be added to a sprint.
Sprint Backlog - The user stories that will be done during the sprint.
Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

== Major Differences ==
All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
Chicken/Pig philosophy -
CRC Cards -

==References==
* [http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf Aigle Methods]
* [http://en.wikipedia.org/wiki/Extreme_Programming Extreme Programming]
* [http://martinfowler.com/articles/newMethodology.html#Crystal The New Methodology]
* [http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method Dynamic Systems Development Methodology]
* [http://en.wikipedia.org/wiki/Adaptive_Software_Development Adaptive Software Development]

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:49:38Z

Lee: /* Adaptive Software Development (ASD) */

== Agile Development ==

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.

== Extreme Programming (XP) ==

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager - Manages the team and its resources.
* Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
* Tracker - One of the programmers, puts together wall charts and progress tracking.
* Programmer
* Tester - Assists in writing tests with the customer and running the tests.
* Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
* Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
* Slack - Lower priority stories that can be dropped if time is limited.
* Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
* Test-first - Every story should have an acceptance test.
* Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
* Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

=== Adaptive Software Development (ASD)===

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

* Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
* Collaborate - Balancing the certain parts of planning with those that are uncertain.
* Learn - The design/build/test cycle.

=== Scrum ===

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig)
Scrum Master - Runs daily scrum meetings
Product Owner - The 'customer' who comes up with user stories.
Developer - Tester or programmer who does the work during the sprints.

* Daily scrum meetings - 15 minutes meeting where developers answer three questions:
** What have you done since the last Scrum?
** What will you do between now and the next Scrum?
** What got in your way of doing work?
* Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
* Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
* Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items
Product Backlog - A collection of user stories that make up what can be added to a sprint.
Sprint Backlog - The user stories that will be done during the sprint.
Burndown Chart - A chart displaying the amount of work left in the current sprint.

=== Dynamic Systems Development Method (DSDM) ===

Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

=== Crystal ===

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:
* Safety (in project outcome)
* Efficiency
* Habitability (ensure that developers are happy with the process)

=== Feature Drive Development (FDD) ===

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

* Project Manager - Administrative lead. Manages resources.
* Chief Architect - Manages the overall design of the project.
* Development Manager - Leads normal daily activities.
* Chief Programmer - Guides and mentors other programmers.
* Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
* Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
* Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:
*Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
*Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
*Plan by Feature - development plan from feature list
*Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
*Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

== Major Differences ==
All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

== Definitions ==
Chicken/Pig philosophy -
CRC Cards -

==References==
http://agile.csc.ncsu.edu/SEMaterials/AgileMethods.pdf
http://en.wikipedia.org/wiki/Extreme_Programming
http://martinfowler.com/articles/newMethodology.html#Crystal
http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:27:03Z

Lee: /* Crystal */

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:21:39Z

Lee:

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:20:38Z

Lee: /* Feature Drive Development (FDD) */

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:19:07Z

Lee: /* Feature Drive Development (FDD) */

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T21:18:22Z

Lee: /* Feature Drive Development (FDD) */

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T20:01:15Z

Lee:

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-22T19:24:34Z

Lee:

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-19T03:19:51Z

Lee:

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-19T03:13:24Z

Lee:

== Extreme Programming (XP) ==

Extreme Programming is one of the most popular agile methodologies. This type of development features frequent small releases

* Complete iteration every 1 - 3 weeks
* Complete release with every iteration

Several types of documentation are used for planning and design purposes:

* User story cards
* Task List
* CRC Cards
* Customer Acceptance Tests
* Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

* Manager
* Coach
* Tracker
* Programmer
* Tester
* Customer

There are 13 goals and practices of extreme programming:
* Sitting together - The entire team sits in an open space
* Whole team - Include everyone necessary to success.
* Informative workspace - Include signs around the workspace to indicate progress.
* Energized Work - Do not overextend members for a long period of time.
* Pair programming
* Stories (User stories) - Small statements of functionality ordered in priority by the customer.
* Weekly cycle -
* Quarterly Cycle
* Slack
* Ten-minute build
* Test-first
* Continuous Integration
* Incremental Design

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.

User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-19T00:50:25Z

Lee: /* Agile Development */

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

== Agile Development ==

Agile software development is a collection of processes and development methodologies that emphasize small iterative cycles that allow for a more dynamic evolution of the software. Unlike the waterfall model, whereby each iteration of development may last nine months or longer, iterations in agile models typically only last a few weeks.

Some benefits of Agile development include:

* The ability to change requirements through time.
* It is much easier to scope the required resources for a task since the task is much smaller
* Having a functional piece of software at the end of each iteration.

While there are many different Agile Development forms, they are all very similar and usually only have a few differences.

== Extreme Programming ==
Frequent small releases (Every week or two)
Complete iteration (Every 1 - 3 weeks)
User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-19T00:43:11Z

Lee: /* Agile Development */

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

== Agile Development ==

Agile software development is a collection of processes and development methodologies that emphasize small iterative cycles that allow for a more dynamic evolution of the software. Unlike the waterfall model, whereby each iteration of development may last nine months or longer, iterations in agile models typically only last a few weeks.

While there are many different Agile Development forms, they are all very similar and usually only have a few differences.

== Extreme Programming ==
Frequent small releases (Every week or two)
Complete iteration (Every 1 - 3 weeks)
User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:44:53Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

== Agile Development ==

== Extreme Programming ==
Frequent small releases (Every week or two)
Complete iteration (Every 1 - 3 weeks)
User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:44:13Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

== Extreme Programming ==
Frequent small releases (Every week or two)
Complete iteration (Every 1 - 3 weeks)
User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:38:06Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

== Extreme Programming ==
Frequent small releases (Every week or two)
Complete iteration (Every 1 - 3 weeks)
User stories are written
Code unit tests first
Pair programming
Emphasis on CRC crds during designs

http://www.extremeprogramming.org

=== Adaptive Software Development (ASD)===
Strong emphasis on Dynamic programming languages
speculate, collaborate, and learn cycles.
http://en.wikipedia.org/wiki/Adaptive_Software_Development

=== Scrum ===
Places emphasis on different roles (Chicken/Pig)
ScrumMaster
Product Owner
Team
Stakeholders

Daily scrum meetings
Sprint review (at end)
sprint retrospective (at end)
Spring planning meeting (at begining)
frequent stackholder meetings

Items
Product Backlog
Sprint Backlog

two to four week 'sprints'

=== Dynamic Systems Development Method (DSDM) ===
Project lifestyle:
feasibility study,
business study,
functional model iteration,
design and build iteration, and
implementation.

http://en.wikipedia.org/wiki/Dynamic_Systems_Development_Method

=== Crystal ===
3 priorities [ safety (in project outcome), efficiency, habitability (developers can live with crystal)]

http://martinfowler.com/articles/newMethodology.html#Crystal

=== Feature Drive Development (FDD) ===
model-driven short-iteration process composed of 5 activities.

Activities:
Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
Plan by Feature - development plan from feature list
Design by Feature - A set of features that can be done in two weeks is sselected. The design is done at the class level.
Build by features - each of the selected features is built. Unit tests and code inspecition a must.

Milestones
Six milestones per feature that are completed sequentially. Percentage of each milestone is kept track o.

=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:22:40Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

== Extreme Programming ==

=== Adaptive Software Development (ASD)===
=== Scrum ===
=== Dynamic Systems Development Method (DSDM) ===
=== Crystal ===
=== Feature Drive Development (FDD) ===
=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:22:18Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

=== Adaptive Software Development (ASD)===
=== Scrum ===
=== Dynamic Systems Development Method (DSDM) ===
=== Crystal ===
=== Feature Drive Development (FDD) ===
=== Lean Software Development (LSD) ===
=== Agile Modeling (AM) ===
=== Agile Unified Process (AUP) ===

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:21:56Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

=== 1) Adaptive Software Development (ASD)===
=== 2) Scrum ===
=== 3) Dynamic Systems Development Method (DSDM) ===
=== 4) Crystal ===
=== 5) Feature Drive Development (FDD) ===
=== 6) Lean Software Development (LSD) ===
=== 7) Agile Modeling (AM) ===
=== 8) Agile Unified Process (AUP) ===

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:21:05Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

== 1) Adaptive Software Development (ASD)==
2) Scrum
3) Dynamic Systems Development Method (DSDM)
4) Crystal
5) Feature Drive Development (FDD)
6) Lean Software Development (LSD)
7) Agile Modeling (AM)
8) Agile Unified Process (AUP)

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:20:50Z

Lee:

The most popular Agile methodology is Extreme Programming (XP). However, there are many other agile process models that have been proposed and used in industry, such as--

1) Adaptive Software Development (ASD)
2) Scrum
3) Dynamic Systems Development Method (DSDM)
4) Crystal
5) Feature Drive Development (FDD)
6) Lean Software Development (LSD)
7) Agile Modeling (AM)
8) Agile Unified Process (AUP)

Compare these methodologies, telling how they are different from XP, and assessing their strengths and weaknesses.

CSC/ECE 517 Fall 2009/wiki3 11 j8

2009-11-18T05:04:38Z

Lee:

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:53:37Z

Lee: /* Definitions */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. [[#ref_1|[1]]] We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

* Serialization - The process of converting an object into a form more suitable for storage or transmission. [[#ref_3|[3]]]
* Deserialization - The process of converting data read from disk or received from a transmission into object form. [[#ref_3|[3]]]
* Immutable Object - An object who's attributes cannot be changed after creation. [[#ref_5|[5]]]
* Thread Safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning. [[#ref_4|[4]]]

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization proxy pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:52:09Z

Lee: /* The Proxy Object */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. [[#ref_1|[1]]] We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization proxy pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:51:51Z

Lee: /* References */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization proxy pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:51:36Z

Lee: /* Introduction */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:51:13Z

Lee: /* Introduction */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. [[#ref_1|[1]]] The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:50:46Z

Lee: /* Drawbacks */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

[[#ref_7|[7]]]

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:50:23Z

Lee: /* References */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:50:03Z

Lee:

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down. [[#ref_3|[3]]]

Immutable objects aid in ensuring thread safety, since they cannot be changed. [[#ref_4|[4]]]

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object. [[#ref_6|[6]]]

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable. [[#ref_6|[6]]]

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class. [[#ref_2|[2]]]

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[5] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]
<div id="ref_6" />[6] [http://java.sun.com/developer/technicalArticles/Programming/serialization/ Discover the Secrets of the Java Serialization API]
<div id="ref_7" />[7] [ http://books.google.com/books?id=ka2VUBqHiWkC&pg=PA312&lpg=PA312&dq=serialization+proxy&source=bl&ots=yXHkMnp_N1&sig=8sTsZWu1ZOaf-cuozd7eQ60JiP8&hl=en&ei=FErVSpHxGeGJtgeF692pAw&sa=X&oi=book_result&ct=result&resnum=6&ved=0CBwQ6AEwBQ#v=onepage&q=serialization%20proxy&f=false Effective Java 2nd Edition page 312]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:41:02Z

Lee: /* References */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
<div id="ref_1" />[1] [http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern What is the serialization pattern ]
<div id="ref_2" />[2] [http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/ Serializing Immutable Singletons]
<div id="ref_3" />[3] [http://en.wikipedia.org/wiki/Serialization Serialization ]
<div id="ref_4" />[4] [http://en.wikipedia.org/wiki/Thread_safety Thread Safety]
<div id="ref_5" />[6] [http://www.javaranch.com/journal/2003/04/immutable.htm Mutable and Immutable Objects]

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:37:02Z

Lee: /* Drawbacks */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:36:53Z

Lee: /* Drawbacks */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:35:54Z

Lee: /* The Proxy Object */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:35:34Z

Lee: /* The Proxy Object */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We could visually represent it as follows:

[[Image:SerialProxy lee.jpg]]

To see this in code we would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed?

* A private static class was added that is Serializable and holds all the same information as the Person class.
* An inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:33:53Z

Lee: /* The Proxy Object */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize.

[[Image:SerialProxy lee.jpg]]

We would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed? A private static class was added that is Seriazliable and holds all the same information as the Person class. Also an inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:32:39Z

Lee: /* Introduction */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[Image:Serial noproxy ee.jpg]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed? A private static class was added that is Seriazliable and holds all the same information as the Person class. Also an inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:31:53Z

Lee: /* Introduction */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[File:Serial noproxy ee.jpg|caption]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed? A private static class was added that is Seriazliable and holds all the same information as the Person class. Also an inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety

CSC/ECE 517 Fall 2009/wiki2 18 ee

2009-10-14T03:30:33Z

Lee: /* Introduction */

=Serialization Proxy Design Pattern=

During system design, immutable classes are preferred to guarantee thread safety and consistent object state. For instance, serialization of immutable classes could cause issues in Java if immutability must be preserved. The Serialization Proxy Pattern aims to make serialization acceptable in that regard. Discuss serialization proxy pattern with regards to the problem, design, implementation details, and idiomatic usage.

==Introduction==

Serialization is the process of converting an object or many objects into a form that can be either written to disk or transmitted across the network. The idea being that these can be read back and loaded as objects within an environment, called de-serialization. Imagine having an application with user objects. When the application is shut down, the objects are written to disk. When the application is started back, the user objects are read from disk and initialized as objects. The objects themselves would be in the exact same state as they were before the system was shut down.

Here is a dipiction of normal serialization. This shows the Person class being serialized and de-serialized:

[[File:{Serial_noproxy_ee.jpg}]]

When the need to serialize objects in Java arises, the most common tool is the Serializable interface. This interface is simply used to indicate that the object is serializable.

Here is a simple example of serialization in java:

ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream("/tmp/foo"));
stream.writeObject(myObject);
stream.close();

This would serialize the object "myObject" into the file "/tmp/foo". Here is a simple example of deserialization:

ObjectInputStream stream = new ObjectInputStream(new FileInputStream("/tmp/foo"));
Object myObject = stream.readObject();
stream.close();

This would take the data in /tmp/foo and deserialize it into the myObject object.

==The Problem==

One issue with serialization under Java is the need for serialization of immutable classes. These are classes that after creation, cannot be modified. Take the following class for example:

public class Person {
String name;
Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }
}

Once the constructor is called, neither name or age can be changed. This class is immutable.

The class is easily serializable with no changes, and could be written to disk easily. A problem arises when the object needs to be de-serialized.

Normally when Java is de-serializing an object, it would call the default constructor Person() and then call the setter on each object attribute. With this object there is no default constructor, nor are there setters for the object's attributes. This was done intentionally to keep the object from changing. Serialization Proxy pattern comes into play here.

==The Proxy Object==

To work around the fact that we can't deserialize an immutable class, we use a proxy object that is an inner class of the class we want to serialize. We would change the Person class as follows:

public class Person {
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String name() { return name; }
public Integer age() { return age; }

private Object writeReplace() {
return new Proxy(this);
}

private static class Proxy implements Serializable {
String name;
Integer age;

public Proxy() { }
public Proxy(Person person) {
name = person.name();
age = person.age();
}

Object readResolve() {
return new Person(name, age);
}
}
}

So what changed? A private static class was added that is Seriazliable and holds all the same information as the Person class. Also an inner private method called writeReplace() is added to the Parent class.

=== Serialization ===

During serialization, the following occurs:

# The object is checked to see if writeReplace() is defined for the Person object.
# The writeReplace() function is called to retrieve the proxy object.
# Serialization takes place on the proxy object instead.

=== Deserialization ===

During deserialization, the following occurs:

# The stored Proxy object is deserialized, resulting in a Proxy object. Since the member variables of the Proxy object are public, it can be deserialized with no issue.
# The Proxy object is examined to determine if it has a readResolve() method.
# Since it does, readResolve() is called, returning a new Person immutable object.

===Benefits===

* The ability to serialize immutable objects.
* The interface of the immutable object does not have to be changed

===Drawbacks===
* Slower than normal serialization
* Cannot handle some objects with circular object graphs. The following is an example of a circular object graph:

public class A {
private B classB;

public A(){}
public getClassB() { return classB };

}

public class B {
private A classA;

public B(){}
public getClassA() { return classA };

}

In this example, class A holds an instance to class B and class B holds an instance to class A.

==Definitions==

- serialization - The process of converting an object into a form more suitable for storage or transmission.
- deserialization - The process of converting data read from disk or received from a transmission into object form.
- immutable object - An object who's attributes cannot be changed after creation.
- thread safety - the ability of a piece of software to be executed by multiple threads at the same time without malfunctioning.

==References==
http://stackoverflow.com/questions/702357/what-is-the-serialization-proxy-pattern
http://lingpipe-blog.com/2009/08/10/serializing-immutable-singletons-serialization-proxy/
http://en.wikipedia.org/wiki/Serialization
http://en.wikipedia.org/wiki/Thread_safety