Software development is not only about programming. When the time factor comes into picture, it means adopting good architectural patterns, adopting code maintenance patterns and much more. 42Square does not hesitate to jump into the modern shiny development platforms and at the same time we follow the best engineering practices for code maintainability.
Software development / engineering practices differ from project to project based on the complexity, extend, and expected life span of the project. We choose appropriate practices whenever required.
What We Offer
Sustainable Software Engineering with modern best practices for development and code maintenance. This enables the team to respond to changes in technologies, dependencies, or product requirements.
CI / CD implementation to ship early and often in small batches to reduce the risk of each release and to minimize time to market.
Architecture Vitality: Continually analyze the architecture and current technology environment and then recommend solutions for improvement.
Derive architectural characteristics from domain-targeted descriptions.
Architecture style refers to how the backend and user interface source code are organized and how they interact with data store. Each architecture style embodies a well-known set of trade-offs that help an architect make the right choice for a particular business problem. One of the popular architecture style nowadays is the Microservice Architecture. Architecture styles can be classified into monolithic and distributed based on the deployment units.
The layered architecture, also known as the n-tiered architecture style, is one of the most common architecture styles. This style of architecture is the de facto standard for most applications, primarily because of its simplicity, familiarity, and low cost. This is a good choice for small and simple applications and also a good starting point for a greenfield project. This monolithic architecture does not have the complexity associated with distributed architectures.
Pipeline (Pipes and Filters) Architecture
Pipeline Architecture is more suited to application tasks that have simple one-way processing. Examples include EDI(Electronic Data Interchange) tools, ETL(Extract, Transform, and Load) tools, and Orchestrators such as
Relatively simple monolithic architecture with two components; core system and plug-in components. Application logic is distributed between plug-ins and core system. This architecture often implements a plug-in registry also.
Service-based architecture is considered one of the most pragmatic architecture styles, mostly due to its architectural flexibility. It is a distributed architecture, yet it does not have the complexity and cost of microservices architecture. This is a natural fit with Domain Driven design. Unlike the other distributed architectures, service-based architecture is capable of preserving ACID (Atomicity, Consistency, Isolation, and Durability) transaction.
Event-Driven architecture is a popular distributed asynchronous architecture style used to produce highly scalable and high-performance applications. It could be used for small as well as large scale systems. Event-driven architecture is made up of decoupled event processing components that asynchronously receive and process events. It could be used stand alone or embedded in other architecture styles. Most applications follow a request-based model with request orchestrator and request processors to handle the request. Another is the event-based model.
Space-Based Architecture Style
The space-based architecture style is specifically designed to address problems involving high scalability, elasticity, and high concurrency issues. It is also a useful architecture style for applications that have variable and unpredictable concurrent user volumes. It got its name from the concept of tuple space, the technique of using multiple parallel processors communicating through shared memory. Space-based architecture relies on caching for the transactional processing of an application. Removing the need for direct reads and writes to a database is how space-based architecture is able to support high scalability, high elasticity, and high performance. Space-based architecture mostly relies on replicated caching, although distributed caching can be used as well.
Orchestration-Driven Service-Oriented Architecture
The orchestration engine forms the heart of this distributed architecture, stitching together the business service implementations using orchestration, including features like transactional coordination and message transformation. This architecture is typically tied to a single relational database, or a few, rather than a database per service as in microservices architectures. Thus, transactional behavior is handled declaratively in the orchestration engine rather than in the database. While this approach might sound appealing, in practice it was mostly a disaster. Offloading transaction behavior to an orchestration tool sounded good, but finding the correct level of granularity of transactions became more and more difficult.
Microservices is heavily inspired by the ideas in domain-driven design (DDD), a logical design process for software projects. One concept in particular from DDD, bounded context, decidedly inspired microservices. Microservices form a distributed architecture: each service runs in its own process, which originally implied a physical computer but quickly evolved to virtual machines and containers.