Evolution of Software Engineering
In this article I am going talk about Evolution of software Architecture from standalone to micro-services.
One-Tier Architecture
On a single device, this type of design incorporates a variety of options.
Configuration, data, and marketing logic are all part of the setup. Since of the services, 1 Tier architecture is one of the most trustworthy sources; nevertheless, managing such an architecture is a bit challenging because data is stored in multiple variations. The layers that makeup 1 tier architecture are listed below.
- Presentation layer — This Includes all classes involved in providing the user interface to the end-user or returning the response to the client.
- Business layer — Includes all of the logic needed by the application to achieve its functional needs while remaining separate from the domain rules.
- Data access layer — This is basically the server that stores an application’s data
Two-Tier Architecture
The best client/server environment is provided by a two-tier design, which allows the user interface to be stored on the client system while the whole database is saved on the server computer.Although business logic and database logic sits on the client rather than the server and they must be maintained. This became possible because of the LAN (Local Area Network).
This diveded into two parts such as,
- Client Application (Client Tier)
- Database (Data Tier)
This method offers some advantages, including superior performance, ease of application design for the 2-tier architecture, and users’ satisfaction with the architecture’s responsiveness. It also creates a homogeneous environment. This system has some drawbacks, including a lack of security, the possibility of expanding users to impair the architectural performance, and a lack of portability.
Three-Tier Architecture
In a three-tier architecture, a middleware sits between the client and server machines.
If a user requires specific information from the server, the user will submit a request, which will be received by the intermediate layer before being sent to the server for processing.
The response will be delivered to the user in the same manner. That is first received by the intermediate layer, which then dispatches the data received from the server to the user’s end. The data logics and business logic may be controlled and stored via middleware.
The use of middleware in a three-tier architecture improves the design’s flexibility and performance. When it comes to advantage, it performs data integrity and security is improved more that the two-tier and at the same time this hides the database structure.
N-Tier Architecture
A Multi-tier Architecture is a software architecture in which different software components, organized in tiers (layers), provide dedicated functionality and this is also known as the “Multitier Architecture”. It is comparable to a three-tier design, except that the number of application servers is expanded and represented in distinct tiers to disperse business logic.
Java EE Architecture is also comes under N-tier architecture.
Developers want to spread out their system even more and that is where internet comes in. Through that Web server, Web container and Application server were introduced.
Web Server
The web server’s role is to store, process, and distribute web pages to clients. The HTTP protocol is used to communicate between the client and the server. The most common type of page supplied is an HTML document, which may include graphics, style sheets, and scripts in addition to the text.
Lets see how the web server works,
when you type an web address, the browser will search the IP address corresponding to that address in the cache file of computer (Because of cookies). If not, then the browser will send the web address to the DNS server to get the IP address.
Apache HTTP Server, Nginx, IIS, LiteSpeed Web Server and, GWS are some of the common web servers out there.
Web Container
This knows how to run the life cycle of server side Java programs like Servlets (java classes executed on the server and are used to generate dynamic web pages), JSP (Java Server Pages), JSF (Java Server Faces) and also web services. After that it will send the responses back to the browser. Apache Tomcat is one of the common example for web container.
Application Server
As the name itself says, it is a type of server designed to install, operate and host applications and associated services for end users and they will provide services for the application such as transactions, security, dependency injection and concurrency. In the hierarchy Application server is the top position and web server is the last position. The main advantages is application server are,
- A mechanism for reducing the size and complexity of the client programs.
- For the need to cache and control the data flow for better performance.
- A mechanism for implementing security for data as well as end-user traffic.
JBoss, Weblogic, Websphere and, Glassfish are some of the common application servers out there.
Enterprise Java Beans (EJB) is a development architecture for building highly scalable and robust enterprise level applications to be deployed on J2EE compliant Application Server such as JBOSS, Web Logic etc.
Microservice Architecture
Microservice architecture, often known as microservices, is a technique for structuring a single application as a series of loosely linked services. Applications usually start as a monolithic architecture (more on that later) and then evolve into a collection of linked microservices over time.
Microservices’ primary notion is that breaking down some types of programs into many little components that operate together makes them easier to design and maintain.
Despite the increasing complexity of the design, microservices still provide several advantages over monolithic structures.
Microservices are currently used in many big firms’ architectures. Netflix was one of the first and most well-known adopters of the technology. Other well-known examples are eBay, Amazon, Twitter and so on.
Advantages of microservices
- Improved fault isolation: The failure of a single module can have little impact on larger applications.
- Eliminate vendor or technology lock-in: Microservices provide you the freedom to experiment with different technology stacks on a per-service basis. There will be fewer dependencies to worry about, and reverting changes will be considerably easier. There is more freedom when there is less code in play.
- Ease of understanding: With added simplicity, developers can better understand the functionality of a service.
- Smaller and faster deployments: Smaller codebases and scope = quicker deployments, which also allow you to start to explore the benefits of Continuous Deployment.
- Scalability: Since your services are separate, you can more easily scale the most needed ones at the appropriate times, as opposed to the whole application. When done correctly, this can impact cost savings.
So this is how it goes from standalone to microservice. Actually there lot more to say in details which will be discussed in the future articles.
