| Lesson 3 | Corba Course Requirements |
| Objective | Discover what you need to take this course. |
CORBA Fundamentals Requirements
This course focuses on CORBA design rather than implementation (the second course in this series concentrates on implementation), so the required software is minimal. A text editor, minimally notepad, vi, simpletext, or emacs, will be needed. You may want to try one of the simple programmer's editors available from the Internet such as Visual Studio Code.
- VS Code from Microsoft
Differences between a Monolithic Application and a Distributed System
The main differences between a monolithic application and a distributed system lie in their architecture, scalability, and complexity.
Monolithic Application:
Distributed System:
Key Differences:
Each approach has its benefits and drawbacks, and the choice between a monolithic application and a distributed system often depends on the specific needs of the project, including its size, complexity, and scalability requirements.
Monolithic Application:
- Architecture: A monolithic application is built as a single, indivisible unit. All of its components, such as the database layer, the application layer, and the user interface, are tightly integrated and run as a single service.
- Development: This approach simplifies the development process since you only need to manage one codebase. It's straightforward to test, deploy, and scale (up to a certain point) as a single entity.
- Scalability: While monolithic applications can be scaled, it often involves scaling the entire application, even if only one part of it requires more resources. This can lead to inefficient use of resources.
- Reliability: In a monolithic architecture, if one component fails, it can bring down the entire application, leading to a single point of failure
Distributed System:
- Architecture: A distributed system is composed of multiple, independent components or services that communicate over a network. These components can be developed, deployed, and scaled independently.
- Development: Developing distributed systems can be more complex due to the challenges of ensuring that the separate components work together seamlessly. This complexity comes with a need for more sophisticated coordination, data consistency, and communication mechanisms.
- Scalability: Distributed systems are highly scalable since each component or service can be scaled independently based on demand. This allows for more efficient resource usage.
- Reliability: These systems are generally more resilient to failure. If one service fails, the rest of the system can continue to operate. However, this requires careful design to handle failures and ensure continuity.
Key Differences:
- Integration vs. Modularization: Monolithic applications integrate all functionalities into a single service, whereas distributed systems modularize functionalities into separate, loosely coupled services.
- Scalability: Monolithic applications can be less efficient to scale compared to distributed systems, which allow for scaling individual components.
- Development and Maintenance Complexity: Monolithic applications are simpler to develop and maintain initially but can become unwieldy as they grow. Distributed systems start with higher complexity due to their distributed nature but can offer greater flexibility and maintainability as they scale.
- Resilience and Reliability: Distributed systems, designed with fault tolerance in mind, can offer higher resilience and reliability by allowing the system to continue functioning even if a component fails.
Each approach has its benefits and drawbacks, and the choice between a monolithic application and a distributed system often depends on the specific needs of the project, including its size, complexity, and scalability requirements.
Interface Definition Language
- Free Corba Download A trial version of OMG Corba
- A free (for noncommercial use) version of ORBacus (formerly known as OmniBroker) [Currently owned MICROFOCUS]
Background: History of Distributed Systems
- Distributed systems: If you are interested enough in CORBA to be examining this course, you probably know a thing or two already about distributed systems. Distributed systems have been around, in one form or another, for some time, although they have not always been called that and they certainly have not always had the flexibility that they do now. To discover where CORBA fits in, let us briefly review the history of distributed systems, starting with legacy mainframes.
- Monolithic Systems and Mainframes: In the beginning there was the mainframe. ENIAC (Electronic Numerical Integrator And Computer) was the first general purpose computer and was invented by John Vincent Atanasoff. It was primarily designed to calculate artillery tables for the Army, it was also used to study the feasibility of thermonuclear bombs. Along with it came hierarchical database systems and dumb terminals, also known as green screens. Mainframes usually cost a great deal to maintain but were capable of serving large numbers of users and had the advantage (or disadvantage, depending on one's point of view) of being centrally managed. Software systems written for mainframes were often monolithic, that is, the user interface, business logic, and data access functionality were all contained in one large application. Because the dumb terminals used to access mainframes did not do any of their own processing, the entire application ran in the mainframe itself, thus making the monolithic architecture reasonable. A typical monolithic application architecture is illustrated in Figure 1.3
