At CityMind, we employ a software development process known as "Interface Driven Architecture" or IDA. A successful software project depends on the successful completion of a number of steps, each with its own objectives and deliverables. We separate the project into two phases, Architecture and Fabrication. For each phase, a separate bid is given.
Phase A: Architecture
1. Project briefing
All projects begin with the Briefing. Here, you tell us your ideas about the project. What are your goals? What constraints will come into play? Are there third-party products (either software or hardware) that your project needs to interact with? During this phase, we engage in "active listening"-seeking to understand your needs by asking questions. We also share with you the risks entailed in any software project and explain how we use Interface-Driven Architecture to consistently achieve successful projects.
- Consult with client on overview of project
- Introduce Interface-Driven Architecture
- "Successful Software Projects: From Architecture to Fabrication" booklet
- Project recommendations--a plan for going forward with your project
During Analysis, the project begins to take shape. In order to understand your business processes, we will often ask to "shadow" those involved in the day-to-day work that the project is concerned with. This "mini-apprenticeship" ensures that we incorporate the way your company works into the software we create. During this phase, we will create personas that mirror the various users (often with different needs and goals for the software) and create a shared vocabulary that identifies the various users, deliverables, and processes the software must account for.
- Review existing business process and infrastructure
- Identify organization/brand position
- Align goals of the client and the software development firm
- Discover personas
- Create use cases
- Develop relational semantics (shared vocabulary)
- Research supporting technologies
- Project Analysis Report
3. Interactive blueprint
Once Analysis is complete, we begin a process of designing how users will interact with the software. This is far more than "look-and-feel"-this process shows users what appears to be functioning software. This "interactive blueprint" is the heart of Interface-Driven Architecture (IDA). User Interface Design is a highly iterative process that asks users for feedback, provides a new iteration of the interface, and asks users again for feedback. This process continues until:
- users tell us that what we've shown them is accurate and complete, and
- we are assured that we know everything we need to create a Software Architecture.
Typical development methodologies keep the user interface hidden from the user until delivery-when it's too late to make changes. The greatest reason (by far) for failed software projects is that the software delivered does not do what users need. By creating the user interface first in conjunction with actual users, we drive out the risk of project failure.
- Define site/application structure
- Create site/application design
- Design user interaction
- Completed User Interface software
4. Usability testing
Usability Testing begins in the late part of the User Interface Design phase. Working with virtual focus groups, we use special software designed for testing user interaction with the interface. One source of project failure is user rejection—the software is just too hard or too frustrating to use. By methodical usability testing, we discover in advance any sources of difficulty or frustration and make any adjustments necessary. While usability testing is routine on commercial off-the-shelf software, it is an unfortunate rarity in the custom software development process
A software vendor not doing usability testing should be prepared to explain what they know that companies such as Apple, Google, and Microsoft (all of whom do extensive usability testing) do not.
- Assemble virtual focus groups
- Test use cases
- Usability report
Phase B: Fabrication
5. Component Modeling
Robust software--software that readily adapts to the changes in your business--is built from individual modules. Each module must be carefully specified. Without this attention to structure, software quickly becomes brittle. In this step, we employ software best practices (known as design patterns), expressed in UML diagrams, and a solid relational database schema. It is, in large part, this step of component modeling that will determine how robust, scalable, and maintainable the final code will be.
- Create domain model
- Create data schema
- Create API (Application Programming Interface)
- Create user documentation/help system
- UML class diagram
- Entity/Relationship persistence diagram
Interface-Driven Architecture makes back-end coding far easier, faster, and less expensive than traditional development methodologies, since the business rules and system requirements have been firmly established. While some shops may specialize in a particular programming language, the language and database should be chosen to best fit the type of project you envision. Further, all code should be fully tested to ensure that deployed software will be free of dangerous “bugs”.
- Code system components
- Perform unit testing
- Perform coverage testing
- Perform load testing
- Beta version of your application deployed to testing server
7. Beta testing
During the coding phase, developers do their best to build robust code. During the Beta Testing phase, dedicated testers do their best to break that code. In too many development shops, beta testing is left as an exercise for the user. But, just as editors help writers produce the best possible product, testers work with coders to ensure that annoying and possibly costly bugs are discovered and “squashed” before the software is launched. At the end of the Beta Testing phase, acceptance testing should be performed. An acceptance test is a formal review in which you agree that the system has been fully and accurately implemented.
- Test all use cases
- Conduct acceptance testing
- Deployment-ready software
When the proceeding phases have been conducted properly, the launch of your project should be a straight-forward process. The Deployment step simply moves the fully tested and accepted software into a live environment, adjusting the necessary parameters in a declarative configuration file.
- Prepare server environment
- Deploy code to production environment from testing server
- Archival DVD with production code and supporting documentation
Once your project is deployed, Live Monitoring regularly checks system performance to provide metrics on usage and load. A monthly report is provided with any steps needed to ensure the ongoing health of your project.
- Ensure stability and continuing performance of the system
- Report on usage and system load
- Monthly System Health Report
If you would like to a complimentary PDF of our 30-page booklet, "Successful Software Projects: From Architecture to Fabrication", explaining Interface Driven Architecture more fully, please click this link.