Recent Changes


The Agile System Development Life Cycle (SDLC)(from ampysoft)
I'm often asked by clients to facilitate workshops overviewing the ideas presented in the **Agile Manifesto** and agile techniques such as **Test-Driven Design (TDD)**, **database** , and how disciplined your approach to agile software development is, you will get different life cycle diagrams. The goal of this article is to describe trefactoring, and **agile change management**. One issue that many people seem to struggle with is how all of these ideas fit together, and invariably I found myself sketching one or more pictures which overview the life cycle for agile software development projects. I typically need one or more pictures because the scope of life cycles change -- some life cycles address just the construction life cycle, some address the full development life cycle, and some even address the full IT life cycle. Depending on your scopehe agile system development life cycle (SDLC), putting it in context from what you may have heard about within the agile community and more importantly within the context of your overall IT efforts.
This article covers:
The scope of life cycles
Iteration -1: Pre-project planning
Iteration 0: Project inception
Construction iterations
Release iterations
Production
Retirement
1. The LifecycleScope
As we described in the book **The Enterprise Unified Process (EUP)** the scope of life cycles can vary dramatically. For example, Figure 1 depicts the Scrum construction life cycle whereas Figure 2 depicts an extended version of that diagram which covers the full system development life cycle (SDLC) and Figure 3 extends that further by addressing **enterprise-level disciplines** via the **EUP life cycle**. The points that I'm trying to make are:
System development is complicated. Although it's comforting to think that development is as simple as Figure 1 makes it out to be, the fact is that we know that it's not. If you adopt a development process that doesn't actually address the full development cycle then you've adopted little more than consultantware in the end. My experience is that you need to go beyond the construction life cycle of Figure 1 to the full SDLC of Figure 2 (ok, Retirement may not be all that critical) if you're to be successful
There's more to IT than development. To be successful at IT you must take a multi-system, multi-life cycle stage view as depicted in Figure 3. The reality is that organizations have many potential projects in the planning stage (which I'll call Iteration -1 in this article), many in development, and many in production.
Figure 1 uses the terminology of the Scrum methodology. The rest of this article uses the terminology popularized in the mid-1990s by the **Unified Process** (Sprint = Iteration, Backlog = Stack, Daily Scrum Meeting = Daily Meeting). Figure 1 shows how agilists treat requirements like a **prioritized stack**, pulling just enough work off the stack for the current iteration (in Scrum iterations/sprints are often 30-days long, although this can vary). At the end of the iteration the system is demoed to the stakeholders to verify that the work that the team promised to do at the beginning of the iteration was in fact accomplished.
FigureScrum. The Scrum construction life cycle.
{http://www.ambysoft.com/artwork/agileLifecycleScrum.jpg}
The Scrum construction life cycle of Figure 1, although attractive proves to be a bit naive in practice. Where does the product backlog come from? Does it get beamed down from the Starship Enterprise? Of course not, it's actually the result of **initial requirements envisioning** early in the project. You don't only implement requirements during an iteration, you also fix defects (disciplined agile teams have a parallel testing effort during construction iterations where these defects are found), go on holiday, support other teams (perhaps as **reviewers** of their work), and so on. So you really need to expand the product backlog into a full work items list. You also release your system into production, often a complex endeavor.
A more realistic life cycle is captured Figure 2, overviewing the full agile SDLC. This SDLC is comprised of six phases: Iteration -1, Iteration 0/Warm Up, Construction, Release/End Game, Production, and Retirement. Although many agile developers may balk at the idea of phases, perhaps Gary Evan's analogy of development seasons may be a bit more palatable, the fact is that it's been recognized that processes such as **Extreme Programming (XP)** and **Agile Unified Process (AUP)** do in fact have phases (for diagrams, see **XP life cycle** and **AUP life cycle** respectively). The **Disciplined Agile Delivery (DAD) lifecycle** also includes phases (granted, I lead the development of DAD). Furthermore, the **Agile MSF** calls its phases/seasons "tracks".
FigureDetailedLifecycle. A detailed agile SDLC.
{http://www.ambysoft.com/artwork/agileLifecycleDetailed.jpg}
FigureEUP 3. The Enterprise Unified Process (EUP) life cycle.
{http://www.enterpriseunifiedprocess.com/images/eup_lifecycle.jpg}
FigureHighLevelLifecycle. The Agile SDLC (high-level).
{http://www.ambysoft.com/artwork/agileLifecycle.jpg}
On the surface, the agile SDLC of Figure 4 looks very much like a traditional SDLC, but when you dive deeper you quickly discover that this isn't the case. This is particularly true when you consider the detailed view of Figure 2. Because the agile SDLC is highly collaborative, iterative, and incremental the roles which people take are much more robust than on traditional projects. In the traditional world a **business analyst** created a **requirements model** that is handed off to an **architect** who creates **design** models that are handed off to a coder who writes programs which are handed off to a **tester** and so on. On an agile project, developers work closely with their stakeholders to understand their needs, they pair together to implement and test their solution, and the solution is shown to the stakeholder for quick feedback. Instead of specialists handing artifacts to one another, and thereby injecting defects at every step along the way, agile developers are **generalizing specialists** with full life cycle skills.
2. IterationNegative1: Pre-Project Planning
Iteration -1, the “pre-Inception phase” in the **Enterprise Unified Process (EUP)**, is the pre-project aspects of **portfolio management**. During this phase you will:
Define the business opportunity. You must consider the bigger business picture and focus on market concerns. This includes exploring how the new functionality will improve your organization’s presence in the market, how it will impact profitability, and how it will impact the people within your organization. This exploration effort should be brief, not all projects will make the initial cut so you only want to invest enough effort at this point to get a good “gut feel” for the business potential. A good strategy is to follow **Outside-In Development’s** focus on identifying the potential stakeholders and their goals, key information to help identify the scope of the effort.
Identify a viable for the project. There are several issues to consider when identifying a potential strategy for the project. For example, do you build a new system or buy an existing package and modify it? If you decide to build, do you do so onshore or offshore? Will the work be solely done by your own development team, by a team from a system integrator (SI), or in partnership with the SI? What development paradigm – traditional/waterfall, iterative, or agile – will you follow? Will the team be co-located, near-located within the same geographic region, or far-located around the world? As you can see there are many combinations of strategy available to you, and at this point in time you may only be able to narrow the range of the possibilities but be forced to leave the final decision to the project team in future iterations.
Assess the feasibility. During Iteration -1 you will want to do just enough feasibility analysis to determine if it makes sense to invest in the potential project. Depending on the situation you may choose to invest very little effort in considering feasibility, for many systems just considering these issues for a few minutes is sufficient for now, and for some systems you may choose to invest days if not weeks exploring feasibility. Many organizations choose to do just a little bit of feasibility analysis during Iteration -1, and then if they decide to fund the project they will invest more effort during Iteration 0. In my experience you need to consider four issues when exploring **feasibility**: economic feasibility, technical feasibility, operational feasibility, and political feasibility. Your feasibility analysis efforts should also produce a list of potential risks and criteria against which to make go/no-go decisions at key milestone points during your project. Remember that agile teams only have a s**uccess rate of 72%**, compared to 63% for traditional projects, implying that almost 30% of agile projects are considered failures. Therefore you should question the feasibility of the project throughout the life cycle to reduce overall project risk.
Iteration -1 activities can and should be as agile as you can possibly make it – you should collaborate with stakeholders who are knowledgeable enough and motivated enough to consider this potential project and invest in just enough effort to decide whether to consider funding the effort further.
3. Iteration0/Warm Up: Project Initiation
The first week or so of an agile project is often referred to as “Iteration 0” (or "Cycle 0") or in The Eclipse Way the "Warm Up" iteration. Your goal during this period is to **initiate** the project by:
Garnering initial support and funding for the project. This may have been already achieved via your **portfolio management efforts**, but realistically at some point somebody is going to ask what are we going to get, how much is it going to cost, and how long is it going to take. You need to be able to provide reasonable, although potentially evolving, answers to these questions if you're going to get permission to work on the project. You may need to **justify your project via a feasibility study**.
Actively working with stakeholders to initially model the scope of the system. As you see in Figure 5, during Iteration 0 agilists will do some **initial requirements modeling** with their stakeholders to identify the initial, albeit high-level, requirements for the system. To promote **active stakeholder participation** you should use **inclusive tools**, such as index cards and white boards to do this modeling – our goal is to understand the problem and solution domain, not to create mounds of documentation. The details of these requirements are modeled on a just in time (JIT) basis in **model storming** sessions during the development cycles.
Starting to build the team. Although your team will evolve over time, at the beginning of a development project you will need to start identifying key team members and start bringing them onto the team. At this point you will want to have at least one or two senior developers, the project coach/manager, and one or more stakeholder representatives.
Modeling an **initial architecture** for the system. Early in the project you need to have at least a general idea of how you're going to build the system. Is it a mainframe COBOL application? A .Net application? J2EE? Something else? As you see in Figure 5, the developers on the project will get together in a room, often around a whiteboard, discuss and then sketch out a potential architecture for the system. This architecture will likely evolve over time, it will not be very detailed yet (it just needs to be **good enough** for now), and very little documentation (if any) needs to be written. The goal is to identify an architectural strategy, not write mounds of documentation. You will work through the design details later during development cycles in **model storming** sessions and via **TDD**.
Setting up the environment. You need workstations, development tools, a work area, ... for the team. You don't need access to all of these resources right away, although at the start of the project you will need most of them.
Estimating the project. You'll need to put together an initial **e****stimate for your agile project** based on the initial requirements, the initial architecture, and the skills of your team. This estimate will evolve throughout the project.
FigureAMDD: The Agile Model Driven Development (AMDD) life cycle.
{http://www.agilemodeling.com/images/AMDD.gif}
4. Development Iterations
During construction iterations agilists incrementally deliver high-quality working software which meets the changing needs of our stakeholders, as overviewed in Figure 6.
FigureDevelopmentCycle. Agile software development process during a construction iteration.
{http://www.ambysoft.com/artwork/agileDevelopmentCycle.gif}
We achieve this by:
Collaborating closely with both our stakeholders and with other developers. We do this to reduce risk through **tightening the feedback cycle** and by improving **communication via closer collaboration**.
Implementing functionality in priority order. We allow our stakeholders to **change the requirements** to meet their exact needs as they see fit. The stakeholders are given complete control over the s**cope, budget, and schedule** – they get what they want and spend as much as they want for as long as they’re willing to do so.
Analyzing and designing. We analyze individual requirements by **model storming** on a just-in-time (JIT) basis for a few minutes before spending several hours or days implementing the requirement. Guided by our architecture models, often hand-sketched diagrams, we take a highly-collaborative, **test-driven design (TDD)** approach to development (see Figure 7) where we iteratively write a test and then write just enough production code to fulfill that test. Sometimes, particularly for complex requirements or for design issues requiring significant forethought, we will **model just a bit ahead** to ensure that the developers don't need to wait for information.
Ensuring quality. Agilists are firm believers in following guidance such as **coding conventions** and **modeling style guidelines**. Furthermore, we **refactor** our application code and/or our **database schema** as required to ensure that we have the best design possible.
Regularly delivering working software. At the end of each development cycle/iteration you should have a partial, working system to show people. Better yet, you should be able to deploy this software into a **pre-production testing/QA sandbox** for system integration testing. The sooner, and more often, you can do such testing the better. See **Agile Testing and Quality Strategies: Discipline Over Rhetoric** for more thoughts.
Testing, testing, and yes, testing. As you can see in Figure 8 agilists do a significant amount of **t****esting** throughout construction. As part of construction we do confirmatory testing, a combination of developer testing at the design level and agile acceptance testing at the requirements level. In many ways confirmatory testing is the agile equivalent of "testing against the specification" because it confirms that the software which we've built to date works according to the intent of our stakeholders as we understand it today. This isn't the complete testing picture: Because we are producing working software on a regular basis, at least at the end of each iteration although ideally more often, we're in a position to deliver that working software to an independent test team for investigative testing. Investigative testing is done by test professionals who are good at finding defects which the developers have missed. These defects might pertain to usability or integration problems, sometimes they pertain to requirements which we missed or simply haven't implemented yet, and sometimes they pertain to things we simply didn't think to test for.
FigureTestFirst. Taking a "test first" approach to construction.
{http://www.agiledata.org/images/tddSteps.jpg}
FigureTestingDuringDevelopment. Testing during construction iterations.
{http://www.ambysoft.com/artwork/agileLifecycleTesting.jpg}
I would rather fail three months into a two-year project than three years into a two-year project.
5. Release Iterations(s): The "End Game"
During the release iteration(s), also known as the "end game", we transition the system into production. Not that for complex systems the end game may prove to be several iterations, although if you've done system and user testing during construction iterations (as indicated by Figure 6) this likely won't be the case. As you can see in Figure 9, there are several important aspects to this effort:
Final testing of the system. Final system and acceptance testing should be performed at this point, although as I pointed out earlier the majority of testing should be done during construction iterations. You may choose to pilot/beta test your system with a subset of the eventual end users. See the **Full Life Cycle Object-Oriented Testing (FLOOT)** method for more thoughts on testing.
Rework. There is no value testing the system if you don't plan to act on the defects that you find. You may not address all defects, but you should expect to fix some of them.
Finalization of any system and user documentation. Some **documentation** may have been written during construction iterations, but it typically isn't finalized until the system release itself has been finalized to avoid unnecessary rework Note that documentation is treated like any other requirement: it should be costed, prioritized, and created only if stakeholders are willing to invest in it. Agilists believe that if stakeholders are smart enough to earn the money then they must also be smart enough to spend it appropriately.
Training. We train end users, operations staff, and support staff to work effectively with our system.
Deploy the system. See my article entitled **System Deployment Tips and Techniques**.
FigureAUPDeployment discipline workflow.
{http://www.ambysoft.com/artwork/aupDeploymentWorkflow.jpg}
6. Production
The goal of the **Production Phase** is to keep systems useful and productive after they have been deployed to the user community. This process will differ from organization to organization and perhaps even from system to system, but the fundamental goal remains the same: keep the system running and help users to use it. Shrink-wrapped software, for example, will not require operational support but will typically require a help desk to assist users. Organizations that implement systems for internal use will usually require an operational staff to run and monitor systems.
This phase ends when the release of a system has been slated for retirement or when support for that release has ended. The latter may occur immediately upon the release of a newer version, some time after the release of a newer version, or simply on a date that the business has decided to end support. This phase typically has one iteration because it applies to the operational lifetime of a single release of your software. There may be multiple iterations, however, if you defined multiple levels of support that your software will have over time.
7. Retirement
The goal of the **Retirement Phase** is the removal of a system release from production, and occasionally even the complete system itself, an activity also known as system decommissioning or system sunsetting. Retirement of systems is a serious issue faced by many organizations today as legacy systems are removed and replaced by new systems. You must strive to complete this effort with minimal impact to business operations. If you have tried this in the past, you know how complex it can be to execute successfully. System releases are removed from production for several reasons, including:
The system is being complete replaced. It is not uncommon to see homegrown systems for human resource functions being replaced by COTS systems such as SAP or Oracle Financials.
The release is no longer to be supported. Sometimes organizations will have several releases in production at the same time, and over time older releases are dropped.
The system no longer needed to support the current business model. A organization may explore a new business area by developing new systems only to discover that it is not cost effective.
The system is redundant. Organizations that grow by mergers and/or acquisitions often end up with redundant systems as they consolidate their operations.
The system has become obsolete.
In most cases, the retirement of older releases is a handled during the deployment of a newer version of the system and is a relatively simple exercise. Typically, the deployment of the new release includes steps to remove the previous release. There are times, however, when you do not retire a release simply because you deploy a newer version. This may happen if you can not require users to migrate to the new release or if you must maintain an older system for backward compatibility.
8. Recommended Reading
**Agile Estimating and Planning by Mike Cohn**
**Agile Estimating Tips**
**Agile Model Driven Development (AMDD)**
**Agile Scheduling Tips**
**Agile Testing and Quality Strategies: Discipline Over Rhetoric**
**Agile Testing Strategies**
**The Criteria for Determining Whether a Team is Agile**
**The Disciplined Agile Delivery (DAD) Lifecycle**
**Evidence that Agile Software Development Scales**
**Examining the Big Requirements Up Front (BRUF) Approach**
**Initial High-Level Architectural Envisioning**
**Initial High-Level Requirements Envisioning**
**Initiating an Agile Project**
**Is Agile Crossing the Chasm?**
**Justifying a Software Development Project**
**The Process of Database Refactoring**
**Translating Scrum Terminology**
**Why Agile Software Development Works: Improved Feedback**
{http://images.amazon.com/images/P/0521540186.01.MZZZZZZZ.jpg} The Object Primer 3rd Edition: Agile Model Driven Development (AMDD) with UML 2
This book presents a full-life cycle, **agile model driven development (AMDD)** approach to software development. It is one of the few books which covers both object-oriented and data-oriented development in a comprehensive and coherent manner. Techniques the book covers include **Agile Modeling (AM)**, **Full life cycle Object-Oriented Testing (FLOOT)**, over 30 **modeling techniques**, **agile database techniques**, **refactoring**, and **test driven development (TDD)**. If you want to gain the skills required to build mission-critical applications in an agile manner, this is the book for you.
{http://www.ambysoft.com/artwork/bookCoverManagingAgileProjects.jpg} Managing Agile Projects
Are you being asked to manage a project with unclear requirements, high levels of change, and/or a team using Extreme Programming or other Agile Methods? If you are a project manager or team leader who is interested in learning the secrets of successfully controlling and delivering agile projects, then this is the book for you. From learning how agile projects are different from traditional projects, to detailed guidance on a number of agile management techniques and how to introduce them onto your own projects, we have the insider secrets from some of the industry experts – the visionaries who developed the agile methodologies in the first place. Managing Agile Projects is edited by **Kevin Aguanno**, a noted speaker and educator on agile project management, and includes contributions from many noted figures in the agile movement.
9. LetUsHelp
I actively work with clients around the world to improve their information technology (IT) practices as both a mentor/coach and trainer. A full description of what I do, and how to contact me, can be **found here**.
{http://www.ambysoft.com/artwork/logoAmbysoft.gif}
{http://www.ambysoft.com/artwork/canadianFlag.gif}
**Copyright** © 2005-2010 **Scott W. Ambler**
**Agile Data (AD)** | **Agile Modeling (AM)** | **Agile Unified Process (AUP)** | **Enterprise Unified Process (EUP)**
{http://www.ambysoft.com/artwork/icons/twitter.gif} Follow Scott W. Ambler on Twitter

{http://liicoo.com/Material/image/teamworks.jpg}
Teamwork: Functional and Intact Teams
EXPLORING TEAMWORK There are many types of work groups and teams that can exist in organizations. Few, however, function at peak levels. Because effective teamwork can be challenging to achieve, CMOE's Exploring Teamwork Workshop assists teams with cores issues such as improving communication, tapping into creativity, maximizing resources, overcoming resistance, dealing with change in a positive way, and increasing productivity.
Exploring Teamwork is a powerful, experienced-based workshop that shows participants how to build and sustain a high performance team, as well as how to develop teamwork skills at the individual level. The experiential nature of the training, combined with adult learning methods, ensures an exciting and memorable event. Participants walk away with an integrated set of skills, knowledge, and plans to renew team spirit, enhance performance, and improve team leadership. When these skills are applied, teams are stronger, more productive, and more aligned in purpose than ever before.
The Exploring Teamwork learning event is tailored for intact teams, cross-functional teams, or a mixed group of individuals. The learning is customized to each organization's specific team issues and needs.
Participants Will: commitment to teamwork
Discover new methods to enhance team effectiveness and produce creative solutions to team challenges
Explore ways to build team motivation and revitalize commitment
Take away tools and resources that will instill team cohesiveness
Gain personal insight about how their individual actions and behaviors either add to or detract from teamwork
Understand the: - Role and value of team leadership in achieving results
- Necessity of effective personal and interpersonal communication
- Ways to utilize the resources and talents within the team
- Importance of goals and vision
- Methods of problem-solving and of handling conflict and differences
Exploring Teamwork is based on extensive ongoing research and the book, Teamwork: We Have Met The Enemy And They Are Us, by Steven J. Stowell, Ph.D and Matt M. Starcevich, Ph.D., Exploring Teamwork contains powerful tools to help every team become more effective. The workshop is a unique learning experience because it balances the theoretical/conceptual side and the practical/pragmatic side of learning. Theory and practice are blended to meet each team's specific needs. TEAM BUILDING RETREATS Our staff can plan and/or facilitate high-impact team building retreats that promote interaction among Executive Teams, Operating Teams, and Cross-Functional Teams. These sessions are designed to enhance performance and unity by focusing on team strategies, goals, relationships, trust, communication, conflict, etc. Active "experiential" learning is used and discussions are facilitated around important and practical issues. Team Building Retreats are designed to support and reinforce functioning teams, as well as teams experiencing some degree of tension or stress. These retreats are for teams of any size and are carefully planned and coordinated around each client's needs and requirements. It can be a one-time experience or part of an ongoing process to maintain optimum performance. SAFETY TEAMWORK Teamwork and safety are inseparable principles. Safe performance depends on trust, cooperation, communications, and personal responsibility. This workshop uses active, experiential exercises to emphasize the role of teamwork and safety and is customized and tailored to the needs of each organization.

system software (tech term .com).
System software refers to the files and programs that make up your computer'swhat is system software?(aleverno)
The operating system. System files include libraries of functions, system services, drivers for printers and other hardware, system preferences, and other configuration files. Theutility programs that are partthe two major categories of system software. Just as the system software include assemblers, compilers, file management tools, system utilites, and debuggers. The system softwareprocessor is installed on yourthe nucleus of the computer when you install yoursystem, the operating system. You can update the software by running programs such as "Windows Update" for Windows or "Software Update" for Mac OS X. Unlike application programs, however, system software is not meant to be run by the end user. For example, while you might use your Web browser every day, you probably don't have much use for an assembler program (unless,nucleus of course, you are a computer programmer). Since systemall software runs at the most basic level of your computer, it is called "low-level" software. It generates the user interface and allows theactivity.
The operating system to interact withis the hardware. Fortunately, you don't have to worry about what the system software is doing since it justmost important program that runs in the background. It's nice to think you are working aton a "high-level" anyway.
software
The file set of any Application Software, graphical, server-side, commercial, open/free, monolithic etc, has allways four universal parts:
software.body=AEN180=
The executables, libraries, static-data files, examples, manuals and documentation, etc. Regular userscomputer. Every general-purpose computer must have read-only access to these files. They are changed only when thean operating system administrator makes an upgrade in this Software.
software.soul=AEN184=
These are files that define how the Software will run, how to use the Content, security, performance etc. Without them, the Software on its own is usually useless.
Depending on your Software, specific privileged users may change these files, to make the Software behaverun other programs. Operating systems perform basic tasks, such as they want.
It is important to provide documentation about
recognizing input from the configuration files.
software.content=AEN193=
Is what receives all the user attention. Is what the user delegatedkeyboard
sending output to be managed by your Product. Is what makes a user throw away your product and use the competitors', if it gets damaged.
Are the tablesdisplay screen
keeping track of a database system, the documents for a text editor, the imagesfiles and HTML pages of a web-server,directories on the servletsdisk
controlling peripheral devices such as disk drives and EJBs of an Application Server, etc.
software.logs=AEN198=
Server Software use to generate access logs, trace files problem determination, temporary files etc. Other types of softwares also use this files, but it is less common.printers.
It is the last class of file, but many times they arefirst program loaded into memory when the most problem generator forcomputer is turned on and, in a system administrator, because their volume can surpass evensense, brings life to the content size. Due this fact, it is important forcomputer hardware. Without it, you to think in some methodologycannot use your word processing software, spreadsheet software, or facility for this issue, whileany other applications.
Without an operating system, you are in design time.
software.example
Let's see how universal is this concept analyzing some types of softwares:
partstable
Pay attention that the Software on its Own contains allcannot communicate with your product business logic, which could be useless ifcomputer. When you hadn'tgive the computer a Configuration to define how to work with a data bundle, provided bycommand, the user. So, Configurations are what connects your product tooperating system relays the user.
We can use a metaphor about a Sculptor (business logic), that needs Bronze (content) and a Theme or Inspiration (configuration) from a Mecenas (user),instructions to produce a beautiful work (content). He make annotations in his Journal (logs) about his day-by-day activities, to report to his Mecenas (user).
separe
OK, so let's be more practical. The fact is, if we correctly use the universal parts concept, we greatly improve'brain' of the quality of our Product. We'll do that simply separating, encapsulating, each one of these parts in different system directories (having only different files for each part is not sufficient). There is a standardcomputer, called FHS that defines the Linux directories for each part, and we'll discuss it later in Section 4.
By now let's see the value of this separationmicroprocessor or CPU. You cannot speak directly to the user:
He gains a clear vision about where is each part, specially his Configurations and Content, and he feels your Product as something completely under control. The clareza brings ease of use, security and confidence in your Product. And in practice it permits him manipulate each part independently
It is clear now that, for instance, when backing up, user action is needed only for Configurations and Content (the puritans will also backup some logs). The user don't have to care about Software on its Own,CPU because it is safe, original, on the product CD, in his shelf.
For upgrades, the new package will overwrite only the business logic, leaving intact the user's precious Configurations and Content. Here is very important to keep old content and configuration compatible, or to provide some tools help migration of data
The logs being keptunderstands machine language. When you are working in a separate filesystem (obviously suggested in your documentation), avoidsan application software program, such as Microsoft Word, commands that their exaggerated growth interfere withyou give the Content, or withapplication are sent through the stability of the wholeoperating system
If your Software follows some directory standards, to the user don't have to reconfigure hisCPU. Windows2000, Window95/98, Mac OS, Unix and DOS are all examples of operating systems.
{http://depts.alverno.edu/cil/mod1/software/images/syssoftpic.gif} Operating system or environment to use it. He will simply Install-and-Use.
example.bodygraphic

system software (tech term .com).
System software refers to the files and programs that make up your computer's operating system. System files include libraries of functions, system services, drivers for printers and other hardware, system preferences, and other configuration files. The programs that are part of the system software include assemblers, compilers, file management tools, system utilites, and debuggers. The system software is installed on your computer when you install your operating system. You can update the software by running programs such as "Windows Update" for Windows or "Software Update" for Mac OS X. Unlike application programs, however, system software is not meant to be run by the end user. For example, while you might use your Web browser every day, you probably don't have much use for an assembler program (unless, of course, you are a computer programmer). Since system software runs at the most basic level of your computer, it is called "low-level" software. It generates the user interface and allows the operating system to interact with the hardware. Fortunately, you don't have to worry about what the system software is doing since it just runs in the background. It's nice to think you are working at a "high-level" anyway.
software
The file set of any Application Software, graphical, server-side, commercial, open/free, monolithic etc, has allways four universal parts:
software.body=AEN180=
The executables, libraries, static-data files, examples, manuals and documentation, etc. Regular users must have read-only access to these files. They are changed only when the system administrator makes an upgrade in this Software.
software.soul=AEN184=
These are files that define how the Software will run, how to use the Content, security, performance etc. Without them, the Software on its own is usually useless.
Depending on your Software, specific privileged users may change these files, to make the Software behave as they want.
It is important to provide documentation about the configuration files.
software.content=AEN193=
Is what receives all the user attention. Is what the user delegated to be managed by your Product. Is what makes a user throw away your product and use the competitors', if it gets damaged.
Are the tables of a database system, the documents for a text editor, the images and HTML pages of a web-server, the servlets and EJBs of an Application Server, etc.
software.logs=AEN198=
Server Software use to generate access logs, trace files problem determination, temporary files etc. Other types of softwares also use this files, but it is less common.
It is the last class of file, but many times they are the most problem generator for a system administrator, because their volume can surpass even the content size. Due this fact, it is important for you to think in some methodology or facility for this issue, while you are in design time.
software.example
Let's see how universal is this concept analyzing some types of softwares:
partstable
Pay attention that the Software on its Own contains all your product business logic, which could be useless if you hadn't a Configuration to define how to work with a data bundle, provided by the user. So, Configurations are what connects your product to the user.
We can use a metaphor about a Sculptor (business logic), that needs Bronze (content) and a Theme or Inspiration (configuration) from a Mecenas (user), to produce a beautiful work (content). He make annotations in his Journal (logs) about his day-by-day activities, to report to his Mecenas (user).
separe
OK, so let's be more practical. The fact is, if we correctly use the universal parts concept, we greatly improve the quality of our Product. We'll do that simply separating, encapsulating, each one of these parts in different system directories (having only different files for each part is not sufficient). There is a standard called FHS that defines the Linux directories for each part, and we'll discuss it later in Section 4.
By now let's see the value of this separation to the user:
He gains a clear vision about where is each part, specially his Configurations and Content, and he feels your Product as something completely under control. The clareza brings ease of use, security and confidence in your Product. And in practice it permits him manipulate each part independently
It is clear now that, for instance, when backing up, user action is needed only for Configurations and Content (the puritans will also backup some logs). The user don't have to care about Software on its Own, because it is safe, original, on the product CD, in his shelf.
For upgrades, the new package will overwrite only the business logic, leaving intact the user's precious Configurations and Content. Here is very important to keep old content and configuration compatible, or to provide some tools help migration of data
The logs being kept in a separate filesystem (obviously suggested in your documentation), avoids that their exaggerated growth interfere with the Content, or with the stability of the whole system
If your Software follows some directory standards, the user don't have to reconfigure his system or environment to use it. He will simply Install-and-Use.
example.body

Answer
The web as is stands (Web1.0) is seen as a "static" thing, like a billboard or a magazine. You can see lots of billboards, buy lots of magazines, enjoy or dislike them but they stay the same until they are changed by the publisher.
"Web2.0 applications" are ones that are "user-generated" or "user-shaped". Instead of being "published" by someone, the people using the site "publish" the content. They also market it and edit it.
Famous examples of "Web2.0 applications" already in use and much talked about are Flickr for photographs, Wikipedia for encyclopedia articles, Facebook for maintaining friendships, YouTube for seeing young people mugging to videocameras and Answers.com for combining syndicated elements of these with its own user-generated Q&A section.
Web 1.0 is like a kind of platform where there are new releases of it. But there is nothing like a new release for the existing ones in web 2.0. Web 2.0 is a kind of service oriented. Web 1.0 was about publishing, not participation; that advertisers, not consumers, ought to call the shots; that size mattered, and that the internet was increasingly being dominated by the top websites. Web 2.0 helps to increase the participation of the users like blogs, e-commerce websites, torrents etc, where every user gets a chance to publish in a website one way or the other.
For Ex: Napster (though shut down for legal reasons) built its network not by building a centralized song database, but by architecting a system in such a way that every downloader also became a server, and thus grew the network.