Architecture Styles
We Don't Re-invent the WheelSoftware architects face the same problems over and over when designing software applications. Instead of re-inventing the wheel everytime on the expense of the project budget, our architects put to work industry-tested architecture styles that have matured over the years.
We build on our cumulative experience and that of fellow software architects in the industry to develop timeless software that provides the highest return on your investment (ROI).
Our architects often choose from the architecture styles below to build commercial-quality applications. These architecture styles are not used exclusively; instead, we usually choose multiple overlapping styles to suit your application requirements and quality attributes.
For example, we might structure your application using both the object-oriented architecture style and the layered architecture style, communicate using the service-oriented architecture style (SOA) and deploy using the 3-tier architecture style.
Service-Oriented Architecture (SOA)We mainly apply the service-oriented architecture style (SOA) for communication when your application problem context calls for the following: platform independence, message-based communication between software components, integrating multiple functionality into a single UI, exposing services for discovery, developing Software plus Service (S + S), Software as a Service (SaaS) or cloud-based applications.
Client-Server ArchitectureIf you're looking to reuse the same business logic from multiple physical client machines, we would consider the client-server deployment architecture style as a great candidate. It's the next step up from a UI and business logic residing on the same machine.
Client-server architecture style is especially called for when there are inbound calls to your application. External software needs a single point of access to your application instead of many residing on multiple client machines.
Also, if you're application calls for independent business logic monitoring functionality, then client-server is a first step that our architects consider.
N-Tier/3-Tier ArchitectureWhen your application demands scalability, a suiteable architecture that we consider is the N-Tier/3-Tier archtiecture. We make sure that your application's layers can be seperated into different physical machines.
By mapping layers to tiers, we can usually create a cluster or a farm on the same tier to increase performance and reliability. For example, our architects could deploy the UI layer to one tier such as a farm of web servers, the business logic to another tier, then the data layer to yet another tier.
In addition, sometimes your application security requirements dictate that we distribute it on many tiers to create a security zone. Under these constraints, for example, the business layer can be placed behind a firewall.
Seperated Presentation ArchitectureYour return on investment (ROI) is greatly diminished when the non-UI layers depend on the UI layer. When the UI and non-UI layers are intertwined you lose the reusability of both.
What happens is that the non-UI layers will not be reusable from a different or multiple UIs. In addition, different non-UI layers such as the business layer will not be swappable.
This situation in turn affects your ROI as you would have to develop new UIs or non-UI layers components from scratch.
Our software architects use the Seperated Presentation style to decouple the UI layer from the non-UI layers to increase your ROI and lower your cost of development when new changes are needed to conquer new markets.
Unless it's deliberately throw-away code, we rarely design our applications without the separated presentation architecture style.
Layered ArchitectureBy far, the layered architecture style is the most often used style in complex software applications. This style allows us to partition the many areas of the application into seperate layers and stack them on top of each other.
We use this architecture style to greatly improve on maintainability, extensibility, reusability and scalability when deployed to tiers.
Object-Oriented ArchitectureWhen using object-oriented architecture, we divide the system into individual, reusable and self-sufficient objects. Each object contains the data and the behavior that the object is responsible for.
The object-oriented architecture usually mirrors real life objects and makes it simpler to model applications. It's a basic, building-block architecture style.
Component-Based ArchitectureWhen using component-based architecture, we divide the application into components that are loosely coupled together. This structure allows for any component to communicate with any other without any layering or stacking order.
These are individual stand-alone components that are reusable, location-transparent, and that expose well-defined communication interfaces.
The component-based architecture enhances the reusability and maintainability of your application.