Overview

Partnering with Universal Mind does not lock you into a one-size-fits-all style of engagement. We tailor how we work with you based on your needs and how you want to work with us. We can mentor your developers, augment your existing team, manage a project, or develop the entire application ourselves — what we call, Full Lifecycle Development.

Sometimes a mixed approach works best. For example, we may function as project leader while we mentor your team so they learn best practices hands-on.

Very often, however, clients ask us to develop the complete application for them. Full Lifecycle Development offers many advantages:

• Speeds development
• Guarantees application functionality and performance
• Frees you and your staff to focus on other priorities
• Reduces the need to hire and manage employees you won’t need later
• Avoids the need for expensive rework later
• Provides a solid foundation on which to build related applications

Just as we tailor best-of-breed technologies to your particular application need, we also tailor best-of-breed development methodologies and practices. But whatever our approach, our commitments remain the same: to stay within budget, stay on schedule, satisfy end-user needs, and meet your business objectives. Along the way, we also commit to making sure you understand and approve our work plan from project start to final sign-off.

Rich Internet Applications (RIAs) — the types of applications we develop — involve the most advanced development concepts in use today. That’s consistent with what RIAs represent — some of the most complex, expressive, and inclusive applications that exist, impacting virtually every layer in the organization’s system architecture.

Universal Mind is an expert in these advanced methodologies and best practices. (We’ve applied them repeatedly on many of the world’s most challenging web application development projects.)

Here is a brief sample of some of the development concepts we use:

Incremental Development

All application development occurs as a sequence of stages — and different development groups apply different names to them, such as:

• Requirements definition
• Architecture design
• Technical design
• Coding
• Quality assurance
• Deployment

The fact that code must be designed before it can be coded, and coded before it can be deployed is self-evident. What incremental development brings to the table is the recognition that different sections of the application can also be developed in stages — validating each section as you go, rather than delay validation until the entire application is developed. Incremental development offers several benefits:

• Reduced Risk
• You don’t have to wait until the entire application is finished to find out if parts of the application work.
• Faster Development
• Multiple sections can be developed in parallel.
• Less Rework
• Studies have shown that going through the development cycle multiple times (once for each stage) rather than just once for the entire application improves developer efficiency.

Design Patterns

What’s the best way to write a class that will never create more than one object? What’s the best way to centralize business logic on behalf of agents deployed across multiple servers? Very often in developing RIAs the same problems come up again and again — and very often lend themselves to best-practice solutions. A great many of these solutions have been captured as design patterns — reusable off-the-shelf code that can be tailored and inserted into an application. Benefits of design patterns include:

• Reduced Risk
• The code has already been proven.
• Faster Development
• Developers don’t waste time reinventing the wheel.
• Better Performance
• The code has been refined repeatedly by expert developers working over time on many different kinds of applications.

Frameworks

Just as design patterns provide best-practice solutions for specific application problems, a framework provides a best-practice approach to an entire application. In the RIA arena, two frameworks stand out: Cairngorm and Mach II. Both employ collections of design patterns and overarching design strategies that have proven time and again to achieve applications that are scalable, flexible, and harder to break.

Mach II, for example, employs a strategy called implicit invocation that makes distributed applications especially scalable. This is when a process announces an event and the system itself invokes all procedures that have registered with that event — so the process need not call (or even know about) every procedure it causes to be invoked.

Benefits of frameworks include:

• Reduced Risk
• The code, and the general architectural approach, has already been proven.
• Faster Development
• Developers don’t waste time reinventing the wheel.
• Better Performance
• The framework has been refined repeatedly by expert developers working over time on many different kinds of applications.
• Key architectural features are built in
• Like scalability, flexibility, high performance, and resistance to breakage.