Jonah uses an Agile approach to software development, synthesizing practices from Scrum and Jacobson’s use-case driven Object-Oriented Software Engineering method. Automated unit testing, continuous integration, source code as the primary artifact, convention over configuration, “just enough” documentation, and frequent, iterative delivery are the cornerstones of our method.
We always begin with some form of Discovery, followed by multiple iterations through Prioritize to Deploy for each story until your solution has fully taken shape. We then transition to providing you with whatever support you require.
- Listen to an overall statement of the opportunity at hand
- Evaluate the vision, business model, target market, goals
- Co-strategize, propose novel ideas, and validate assumptions
- Form Creative Brief, High-level requirements, High-level plan and estimate
- Categorize and evaluate technical, financial, resource, and time constraints
Discovery occurs once at the beginning of a project. The main products of the discovery phase are the creative brief, scope statement, a detailed project plan, and cost estimation. During the discovery phase we elicit and document the vision, business case and scope of the project. The scope is defined by the list of use cases that describe the features and functions of the application. We flesh out the details of several representative use cases to understand the complexity of the application.
- Re-establish relative feature priorities, deferring low-value, high-cost features
- Consider timing of iteration
- Identify Factor-X
The priority of the remaining use cases to be developed is re-evaluated at the beginning of each iteration or sprint. It’s sometimes surprising how much priorities may have shifted in a 3-4 week period, as the outcome of one iteration often informs the choices made for subsequent ones. For example, some use cases may have been subsumed by or made unnecessary by those developed in the previous iteration.
The relative importance of Scope, Time, Price, and Capacity may all be re-evaluated during prioritization. This might result in scope alterations or even changes to the overall development roadmap. Typically, the high-value, low-cost features are chosen for development first, with low-value, high-cost features deferred, potentially indefinitely. The need to quickly identify the X-factor - the most risky unknown - is also a concern.
- Elaborate Site Map
- Elaborate Use Cases and Scenarios
- Elaborate content categories and placement
During analysis we complete the sitemap and use cases for the functions scheduled during the current iteration. The project plan, scope and cost estimate are refined and critical resources are identified. Scenarios and test cases are created from the use cases.
We focus on the user's experience to create the first cut of the Interactive Architecture for the features within the iteration. The Interactive Architecture specifies the user's model of the application, content categories, navigation hierarchy, and placement.
- Elaborate technical and interactive architectures
- Propose custom visual designs in support of intuitive and direct user experiences
- Flesh out scenarios, storyboards, detailed, wireframes
- Consider deployment impacts
During Design, the technical architecture and the interactive architecture are specified in detail relative to the features to be developed during that iteration.
Object models and sequence diagrams are created from the use cases to describe the static and dynamic nature of the application. The Jonah Group has been developing object-oriented systems for over ten years. We are experts in creating object-oriented business models. Deployment diagrams are created to describe the tiers and processing nodes required to support the application.
Our interface design activity creates intuitive and engaging user experiences. The information architecture ties the data dictionary, navigation features and content types into a cohesive site map.
Building on the Information Architecture, we create user scenarios, storyboards, wireframes and site maps to precisely describe the interface before the effort moves to the build stage. If necessary, usability of the interface can be tested at this point to ensure that our assumptions about the user experience are accurate.
For software projects, user goals and activities drive the Interactive and Technical Designs. For marketing and brand-focused projects, branding and content strategies and user stories drive the Interactive Design.
- Translate Designs into source code and unit tests, segmented in multiple tiers (web, business, service, data)
- Extend and maintain development and integration (continuous build) environments
- Integrate new third-party tools and libraries
During the build phase designs are translated directly into source code so the application mirrors the business environment directly. We develop object model programs to model the business environment, transaction programs to update the model, web pages or forms to present the model, databases to store the model and connectors to integrate other systems.
We develop automated unit tests in parallel with the code. These tests are run each evening to ensure that new code doesn't break existing code. Simple structural rules are coded directly into business object programs. Complex logic that affects several business objects is coded into transaction programs. Transaction programs are layered on top of the business object programs.
We use the site map and interactive architecture to render web pages that create the look and feel of the system. Input validation and other simple business rules are coded directly into the web pages to improve the user's experience. These pages are integrated with server-side business logic.
All non-trivial web applications must work with other business systems. These systems include relational databases, transaction monitors, mainframe applications and third-party systems. In many cases, these systems are operated by other companies. The Jonah Group has extensive experience integrating databases, operational support systems and enterprise systems with web sites, content management systems, 3rd party components, and applications.
- Release the application to the test environment
- Perform integration and regression testing
- Elaborate operations scripts and processes
In addition to the automated unit tests created during the build phase, we test the end-to-end functions of the application at the end of each iteration. The application is deployed to the test environment so capacity testing can be performed.
Installing the application in the test environment at the end of each iteration forces operations staff to take ownership of the application long before the application is released to end users. Operations scripts and processes can be developed in parallel with the application, which reduces the overall duration of the project. During the test phase, defect reports are collected and analyzed. Defects identified in early iterations can be fixed in later iterations.
- Deliver the system to the production environment, where value can be realized by the user community
- Run smoke tests, as appropriate
- Support operations staff, training staff, and users
During deployment, the application makes the transition to its user's community, which includes manufacturing, delivering, training, supporting, and tuning the application until the users are satisfied.
New story development can continue (beginning with Prioritize) while released stories provide interim value and ROI.
Once the application is deployed, warranties and service level agreements come into play to ensure the ongoing success of the application. Training materials are developed to help users make the transition to the new application. Finally operations scripts are developed to help manage the application.
- Bug Fixing
- Site Monitoring and Management
- Backups and Archiving
- Scaling, Redeployent
Support can begin whenever the application has been deployed. Feature development can still continue, but in general, a number of new maintenance activities come into play once the application has transitioned to the production environment.
Bugs are fixed in the bugfix environment and deployed to production independently of the latest features being developed. Operating system and framework patches may be installed and tested, and components may be upgraded. The ongoing health of the site is monitored, and steps are taken to deal with whatever issues arise in production.