Toronto, Ontario, Canada - 19. Aug 2005 - Enomaly has revised its project management and development methodologies. The new methodologies combine several process including agile, extreme programming and Iterative and Incremental development.

Enomaly's web site and application consulting services bring together an extremely rich set of skills and experience-tuned perspectives. Our real value is consistently demonstrated through our ability to carefully listen to and understand the needs of our clients and to translate those requirements into a solution that fits their budget and meets their present and future operational needs.

In developing a large scale Open Source project, a detailed needs analysis should be preformed before commencement on any development work. Many small companies overlook this step. However, to effectively manage anything, you need a process regardless of the size of the company or project. At our company we have the mentality of be small, act big. When starting a new project regardless of size, having a detailed process defined beforehand will greatly reduce the chance of errors, problems and delays. There are a number of different methodologies, practices and best approaches to choose from. Our primary methodology is based on the Iterative and Incremental development approach.

Iterative and Incremental development approach

The idea of iterative enhancement is to develop / implement an open source software system incrementally, allowing the developer to take advantage of what was learned during the development of earlier, incremental, deliverable versions of the system. Learning comes from both the development and use of the system, where possible. Key steps in the process are to start with a simple implementation of a subset of the software requirements and iteratively enhance the evolving sequence of versions until the full system is implemented. At each iteration design modifications are made along with additional new functional capabilities.

The procedure itself consists of the initialization step, the iteration step, and the project control list. The initialization step creates a base version of the system. The goal for this initial implementation is to create a product to which the user can react. It should offer a sampling of the key aspects of the problem and provide a solution that is simple enough to understand and implement easily. To guide the iteration process, a project control list is created that contains a record of all tasks that need to be performed. It includes such items as new features to be implemented and areas of redesign of the exiting solution. The control list is constantly being revised as a result of the analysis phase.

The iteration step involves the redesign and implementation of a task from project control list, and the analysis of the current version of the system. The goal for the design and implementation of any iteration is to be simple, straightforward, and modular; supporting redesign at that stage or as a task added to the project control list. The code represents the major source of documentation of the system. The analysis of iteration is based upon user feedback and the program analysis facilities available. It involves analysis of the structure, modularity, usability, reliability, efficiency, and achievement of goals. The project control list is modified in light of the analysis results.

Project Control List steps:

• Any difficulty in design, coding and testing a modification should signal the need for redesign or re-coding.
• Modifications should fit easily into isolated and easy-to-find- modules. If they do not, some redesign is needed.
• Modifications to tables should be especially easy to make. If any table modification is not easily done, redesign is indicated.
• Modifications should become easier to make as the iterations progress. If they don’t, there is a basic problem such as a design flaw or a proliferation of patches.
• Patches should normally be allowed to exist for only one or two iterations.
• Patches may be necessary to avoid redesigning during an implementation phase.
• The existing implementation should be analyzed frequently to determine how well it measures up to project goals.
• Program analysis tools should be used whenever available to aid in the analysis of partial implementations.
• User reaction should be solicited and analyzed for indications of deficiencies in the current implementation.

The Waterfall Method

Iterative and Incremental development is a software development process that can be used in place of the waterfall model, a software development model first proposed in 1970 by W. W. Royce. The waterfall model sees development as flowing steadily through the phases of requirements analysis, design, implementation, testing (validation), integration, and maintenance.

Royce advocated using the model repeatedly, in an iterative way. However, most people don’t know that and have discredited it for use as a Real World process. In practice, the process rarely proceeds in a purely linear fashion. Iterations, by going back to or adapting results of the precedent stage, are common. Stages include; concept; requirements definition; system and software design; implementation and unit testing; integration and system testing; and maintenance.

Cowboy Coding

Another very common approach to software developed is generally referred to as Cowboy coding.
Cowboy coding is the absence of a defined method: team members do whatever they feel is right. This is not a recommended approach.

The Enomaly Approach:

At Enomaly, we modified the Iterative and Incremental approach and the waterfall model to create our own hybrid called The Enomaly Approach.

Phase 1
Investigation
+ Develop deep understanding of project goals and obstacles
+ Analyze company's current situation and competitive landscape
+ Define project objectives and scope
+ Identify team members & contractors that may need to be included in the project
+ Determine conclusions

Phase 2
Exploration
+ Look at design and technical possibilities based on Phase One conclusions
+ Build prototypes and test uncertainties
+ Select technologies
+ Define creative direction

Phase 3
Definition
+ Refine and confirm concept
+ Define content/technical architecture
+ Develop detailed interface and technical design
+ Start user testing

Phase 4
Implementation
+ Prepare for production
+ Create design documentation and style guide
+ Produce textual content
+ Execute coding and functional testing
+ Graphic design, coding and functional testing
+ Continue user testing

Phase 5
Integration and Testing
+ Integrate design and technological solutions
+ Test systems for functionality and performance
+ Fine tune for best performance
+ Prepare production environment

Phase 6
Launch
+ Product release
+ Implement publicity efforts
+ Post-launch monitoring and optimization

------------------------------
Project Management Methodology

After defining a methodology such as the Iterative and Incremental development approach, a complimentary project management process needs to be adopted. Generally, there are two approaches to project management. The "traditional" approach identifies a sequence of steps to be completed. The "spiral" approach is the completion of one of the small tasks leads to the beginning of the next.

The Traditional Approach

In the traditional approach, we can distinguish 5 components of a project in the development of an application:

1. Project initiation (kickoff)
2. Project planning
3. Project production or execution
4. Project monitoring or controlling
5. Project completion

The Spiral Approach

In the spiral approach, also referred to as the agile software development approach, the project is seen as relatively small tasks rather than a complete process. The objective of this approach is to impose as little overhead as possible in the form of rationale, justification, documentation, reporting, meetings, and permission.

While the names may differ from industry to industry, the actual stages typically follow common steps to problem solving--defining the problem, weighing options, choosing a path, implementation and evaluation.

Project management tries to gain control over five variables:

1. Time
2. Cost
3. Quality
4. Scope
5. Risk

Project Management is divided into five parts:

1. Requirements analysis
2. Architecture and design
3. Procurement
4. Development or construction
5. Maintenance or post development system (or software) support

Requirements analysis starts the process by defining the requirements and specifications; first in coarse terms; followed by increasingly refined terms; until a clear concept of operation and design can emerge. It is critical to the remaining steps that this first step be complete and not changed, because the cost to make changes to the requirements is exponential as one moves forward.

Architecture and design is the mapping, conceptualization and organization of the application and underling components.

Procurement is the acquisition of raw material like content, software, hardware and relevant technologies.

Development or construction includes implementation and installation of the project including testing.

Maintenance and post development system/support takes place after you have created the application and it exists in a real environment. Tasks including monitoring the system for security vulnerabilities, load and performance issues, system errors etc.

About An Enomaly, Our focus, your content - Open Source Consultants
Back