What is the Hierarchical Nature of Software Quality?

4.8
What is the Hierarchical Nature of Software Quality?

Hierarchical architecture considers the whole system as a hierarchical structure where the software system is broken down into logical subsystems or modules.

Hierarchical architecture considers the whole system as a hierarchical structure where the software system is broken down into logical subsystems or modules with different hierarchy levels. This approach is usually employed when designing Software for network protocols or operating systems. In the design of the software hierarchy in a system, a low-level subsystem offers services to its higher levels of subsystems, and they invoke the processes at the lower levels. Lower layers provide additional functionality, e.g., I/O, transaction, scheduling security services, etc. The middle layer can offer more domain-specific functions, e.g., business logic and core processing services. The upper layer is more abstract through user interfaces such as GUIs, shell programming tools, and more. Each design type can be incorporated into this hierarchical structure and frequently incorporate other architectural styles.

Architectural styles with hierarchical structure in Software is classified into --

* Main-subroutine

* Master-slave

* Virtual machine

Main-subroutine:

This style aims to reuse modules and then develop the subroutines or modules on their own. In this fashion, the software system is broken down into subroutines applying top-down refinement under the program's requirements.

These improvements lead to verticalization until the decomposed module becomes easy enough to be sole responsibility. Functionality can get reused or shared among many callers in the higher layers.

There are two ways in the data can be passed in subroutines as parameters, for instance, and

* Pass By Value Subroutines use only the previous data, but they cannot modify it.

*Pass by Reference Subroutines can be used to change the value of information referenced in the parameter.

Advantages:

• Easy to disassemble the system based on the hierarchy refinement.

* It can be used as the subsystem of an object-oriented design.

Disadvantages:

* Easily hacked because it contains globally shared information.

* A tight coupling could result in more ripple effects due to modifications.

Master-Slave:

This method is based on the "divide and conquer" concept and provides fault-based computation and accuracy of computation. It is a modification to the main-subroutine structure that ensures security, reliability and handling faults.

In this model, the slaves offer duplicate services to the master. The master then chooses one of the slaves based on a specific algorithm for selection. The slaves can execute the same function using different algorithms and techniques or perform entirely different functions. This includes parallel computing, where all slaves may be run in parallel.

Implementation of the Master-Slave pattern is based on Five Steps:

* Define how the computation task can be broken down into equal sub-tasks. Identify the sub-services needed to complete the sub-task.

* Indicate how the final results of the entire process can be computed using the help of the results derived by processing each sub-task.

Create an interface to the service you identified in step 1. The slave executes it and is then used by masters to manage the task of each sub-task.

* Install the slave components under the specifications outlined in the preceding step.

The master should be implemented following the specifications developed in steps 1 to 3.

Applications:

* Ideal for applications where the security of Software is an important issue.

* Widely utilized in the field of distributed and parallel computing.

Advantages:

* Faster computation and simple scaling.

* Provides security because slaves can be duplicated.

* Slave could be implemented in a different way to reduce semantic mistakes.

Disadvantages:

* Communications overhead.

* Not all issues can be divided.

* It is difficult to implement and has a portability issue.

Virtual Machine Architecture:

Virtual Machine architecture tries to mimic some function that isn't built into the hardware or Software it's implemented. Virtual machines are built on top of an existing system and offer abstraction and a set of attributes and functions.

In the virtual machine model, the master utilizes the same subservice that the slave uses and can perform tasks like split work, call slaves and then combine the results. Developers can use it to simulate and test platforms that aren't yet constructed and create "disaster" methods that are expensive, complex or risky to be tested on a real system.

Most of the time, virtual machines separate the programming language or application environments from an execution system. The goal is to offer a portable interface. The interpretation of a specific module using Virtual Machines Virtual Machine may be perceived as an -

* The engine interprets one of the instructions from the program that is being an interpreter.

Based on the request that the engine receives, it changes the internal state, and the procedure is repeated.

The hypervisor, the virtual machine monitor, is a part of the host OS and assigns the appropriate resources to each guest OS. When a guest initiates a system call that the hypervisor intercepts, it converts it into a system call supported by the host OS. The hypervisor manages each virtual machine's access to the memory, CPU I/O devices, persistent storage, and the network.

Applications:

Virtual machine architecture can be used for the following areas:

* It is suitable to solve a challenge through simulation or translation when there isn't an immediate solution.

Examples of applications include microprogramming interpreters, XML processing, script command language execution rules-based system execution, Smalltalk and Java interpreter programming language.

Examples of standard virtual machines include interpreters, rules-based systems, syntactic shells and command processors.

Advantages:

* Machine platform independence and portability.

* The simplicity of software creation.

* Allows flexibility by the capability to interrupt and query the program.

* Simulation of the working models for disasters.

* Introduce changes during the time of running.

Disadvantages:

* Insufficient execution of the interpreter because of the nature of the interpreter.

* It is possible to incur a cost for performance because of the additional calculations required in the execution.

Layered Style:

This way, the system is divided into a variety of upper and lower layers in an orderly manner, and each layer is responsible for its accountability in the system.

* Each layer is the classes of a related group contained within a package, the form of a deployed component or as a set of subroutines in the format of a method library or header files.

* Each layer offers services to the layer below it and acts as a client for the layer below it, i.e. the layer I request +1 invokes the services provided by layer I over its interface to layer I. The response can be returned to layer i+1 after the task is complete; however, layer I continue to call services provided by layer I -1 down.

Applications:

The layer style is appropriate in the following areas :

* Applications that provide distinct categories of services organized according to hierarchy.

* Any application that could be broken down into application-specific and platform-specific parts.

* Applications that clearly define distinctions in core services from crucial services and user interface service and so on.

Advantages:

* Design is based on increments of abstraction.

* Provides independence for enhancements because changes to the purpose of one layer impact at least two layers.

* Separation between the interface standard from its implementation.

* It's implemented by component-based technology that allows the system to be much more flexible to permit plug-and-play of new components.

* Each layer is an abstract machine deployed differently that allows portability.

* It is easy to break down the system according to the requirements of the tasks in a top-down refinement method

* There are different versions (with the same interfaces) of the same layer that may be utilized interchangeably

Disadvantages:

* Many systems and applications aren't easily organized in a multi-layered manner.

* Runtime performance is lower since clients' requests or responses to a client's request must pass through several layers.

* There are also concerns about the overhead of buffering and data marshalling for each layer.

* The opening of interlayer communication can cause deadlocks "bridging" in tight coupling.

* Error handling and exceptions is a problem within the layered architecture because the faults of one layer need to be spread out to all the layers, calling them

Closing words:

The hierarchical structure of Software's quality is based on a set of quality standards that each have various metrics or measures related to it. SoftCircles, LLC, is a well-known Software development firm in Texas efficiently providing the software industry with new ideas.