The Prologue of Software Abstraction Techniques - Article Example

Student Name: _____________ Student ID: _______________ Tutorial No:_____ Group No: _____ ABSTRACT Abstraction techniques for instance, high level programming languages as well as abstract data have greatly improved people’s ability to specify and develop software. However, due to complexity, different problems have been introduced, but these problems cannot be solved by the current techniques used. This paper will try to evaluate critically on Shaw’s and Parna’s suggested thoughts of demodulation or modularization used as a mechanism for flexibility as well as comprehensibility. The criteria or process used in arriving to a particular decomposition as per Shaw’s and Parna’s are discussed bellow. INTRODUCTION The prologue of software abstraction techniques has been realized. This technique has proven to be significant since it has provided several techniques used in the programming language, structures-algorithm, different strategies, structures algorithms as well as data types. Its fundamental significance is clearly evident when the abstraction eliminates any possible or traces of clerical errors during the decomposition. Different abstractions have been developed by Parna and Shaw. However, Parna and Shaw work towards achieving the same goal; this is, eliminating clerical errors. The development of software abstraction follows a well established pattern in order to solve any impending problems in within the software. This pattern is commonly referred to as ud hoc. In this section, problems are easily identified and a solution is given thereafter. As a result of ud hoc, information is easily understood by different software programmers. On the other hand, new challenges have been instituted by the development of new software. There is a strong correlation between Shaw’s and Parna’s observation. The relationship between Shaw’s and Parna’s observation is clearly stated. Shaw observed that the spirit of abstraction is through identifying, defining, analyzing, naming and providing different ways to invoke the pattern with no error intervention. This process holds back the information of the pattern implementation, thus it reduces any possibility for clerical errors and as a result, it simplifies the understanding. Whereas, Parna observed that when a system is maintained in a modular fashion; it paves way for the system errors to trace specific modules, and as a result it limits the extent of detailed errors (Shaw, 2000). In addition, Shaw observed that when an individual abstraction is developed it usually follows a specified or common pattern. By doing so, some of the solution which had accumulated turns out to be much better. He further observed that important solution are understood when abstraction is carried out in a systematically, analyzed and when they are codified. On the other hand, Parna observed that modularization must be made first before an independent module work begins purposely for design decision. She further made an observation (Shaw) that when a system is arranged hierarchically, such that each layer provides service to the layer above, it is often understood. Alternatively, Parna observed that it is much better to use a relation between programs because in many instances, one module largely depends upon part of another module. Parna further observed that if all modules, this is, the first and the second modules works at the same level, it may give rise into two benefits, this are; different parts of the system are simplified and as a result they tend to use the services of lower 2 levels. Second, Parna observed that if we cut off the upper level, it can still have a useful product. . DISCUSSION Parna’s work was based on two different modules. Each and every module had different subsystem modules working different. Shaw’s work build on that of Parna’s in such a way that she (Shaw) uses higher-level languages which emerged since good programmers acknowledged useful structures. Her useful organization made or build were majorly pipes and filters. Each modules is build in such a way that it accepts the stream of input and emit a stream of output; which involves a local transformation of the input stream, and thus making the module a filter. The module is connected together through the connectivity of the output stream (filters) of one module to act as input (a pipe) stream (Parnas, 1972). Shaw’s further build her work on compilers. For instance, Shaw provided different examples of compliers that may be used for decomposition purposes, this were lexical analyzers, which are instances for filters. In the process of trying to build the work done by Parna, Shaw states that the choice of implementing a strategy largely depends on the characteristics of the application used. For instance, she suggests that the strategy for implementing any sort of storage function includes data bases, arrays, symbol table and files. She (Shaw) provide different access pattern and data models. It also has different ability of accommodating heterogeneous data that has different response and time. Shaw builds on informal analysis and organization of data which Parna failed to address. She provided bases used in developing formal specification, such as; informal description, general domain, implication of design and so on. Shaw developed abstraction technique for the improvement in the programming practice, which has provided specification techniques, programming language, program structures for instance, algorithms as well as data in order to correct some of the things Parna missed in his work. In his essence, he came up with an abstraction which could recognize pattern, defining it, analyzing, naming it, finding different ways to specify it and last but not least, it invoked different patterns by its name without creating an error. This process reduces possible chances for clerical error and thus simplifies person’s understanding. Shaw’s relevant points in relation to modern system and software architecture are developed in a way that they are able to recognize useful system organization. This include: pipes and filter- this is where the pipe which is considered as an input is connected to the filters (output), data abstraction- provides useful ways that can be used to organize a particular software, Layered system- is a system that is arranged in a hierarchically, rule-based system-this occurs where computation is organized, and each one of them gives a rule which it operates and when it does apply, last but not least is the blackboard system- this is where the central data represents the existing state of computation, each one of them is responsible for certain update, check of the existing state and it is responsible for receiving certain knowledge . Another significant point made by shaw in relation to software architecture is basically based on ruled-based system. She states that, ruled based system is important for the application in which various kinds of knowledge made and used in the interpretation of data are defined. Based on this system, she states that the current or modern states are represented with the implementation of different processes such as expertise implements. The modern architectural description of system is usually specified to the system implemented and it may used as a means of communication or storage. Shaw failed to address the steps used in the processing module which is an important process in the decomposition. The first common step for decomposition process is to make a flow chart. This is considered as the most common approach used in decomposition or rather modularization. The flow chart is helpful in abstraction. The second step that Shaw failed to address is the information hiding as a criterion. Every module used in the second decomposition is often characterized by design decision that hides from the rest. CRITICAL ANALYSIS The development of individual abstractions over and over again follows a common known pattern. First, predicaments are solved ud hoc. As know-how accumulates, some explanation turns out to work much better as compared to others, and a type of folklore is passed casually from one person to the other person. In the long run, the useful explanation is understood more methodically, and they are codified as well as analyzed. This enables the development of models that support routine execution and theories that permit the extension of solution. In certain problem domains, a single pattern may predominate. The existing pattern may be used since it is familiar even as other organizations are considered much better. For instance, the Unix community where pipes and filters are considered as the most preferred system structure. As time goes by, the abstractions capture larger amounts of facet with more precision. This in turn allows more and more multifaceted programs to be described with a given amount of effort. This pattern can however be seen, for instance, in the development of higher-level programming languages as well as in abstract data types. Shaw states that there are different strategies used for implementing the storage function of symbols, files, arrays and symbols. All these storage function have different pattern according to the function they both perform. Conclusion A lot of system descriptions provide evidence of abstraction at the architectural level. As per the above statement, it is much clearer that, development of software is now possible. Identification, codification, and dissemination are the three chief problem areas that are likely to affect software’s development. Subsystems paved way for variety of implementation of the function t which they provide. The choice, taste and preference of the implementation strategy largely depend on the characteristic of the application. REFERENCE LIST Parnas, D. (1972). On the Criteria To Be Used in Decomposing Systems into Modules. USA: Carnegie-Mellon University. Shaw, M. (2000). Larger Scale Systems Require Higher-Level Abstractions. USA: Carnegie Mellon Univers. Read More

On the other hand, Parna observed that modularization must be made first before an independent module work begins purposely for design decision. She further made an observation (Shaw) that when a system is arranged hierarchically, such that each layer provides service to the layer above, it is often understood. Alternatively, Parna observed that it is much better to use a relation between programs because in many instances, one module largely depends upon part of another module. Parna further observed that if all modules, this is, the first and the second modules works at the same level, it may give rise into two benefits, this are; different parts of the system are simplified and as a result they tend to use the services of lower 2 levels.

Second, Parna observed that if we cut off the upper level, it can still have a useful product. . DISCUSSION Parna’s work was based on two different modules. Each and every module had different subsystem modules working different. Shaw’s work build on that of Parna’s in such a way that she (Shaw) uses higher-level languages which emerged since good programmers acknowledged useful structures. Her useful organization made or build were majorly pipes and filters. Each modules is build in such a way that it accepts the stream of input and emit a stream of output; which involves a local transformation of the input stream, and thus making the module a filter.

The module is connected together through the connectivity of the output stream (filters) of one module to act as input (a pipe) stream (Parnas, 1972). Shaw’s further build her work on compilers. For instance, Shaw provided different examples of compliers that may be used for decomposition purposes, this were lexical analyzers, which are instances for filters. In the process of trying to build the work done by Parna, Shaw states that the choice of implementing a strategy largely depends on the characteristics of the application used.

For instance, she suggests that the strategy for implementing any sort of storage function includes data bases, arrays, symbol table and files. She (Shaw) provide different access pattern and data models. It also has different ability of accommodating heterogeneous data that has different response and time. Shaw builds on informal analysis and organization of data which Parna failed to address. She provided bases used in developing formal specification, such as; informal description, general domain, implication of design and so on.

Shaw developed abstraction technique for the improvement in the programming practice, which has provided specification techniques, programming language, program structures for instance, algorithms as well as data in order to correct some of the things Parna missed in his work. In his essence, he came up with an abstraction which could recognize pattern, defining it, analyzing, naming it, finding different ways to specify it and last but not least, it invoked different patterns by its name without creating an error.

This process reduces possible chances for clerical error and thus simplifies person’s understanding. Shaw’s relevant points in relation to modern system and software architecture are developed in a way that they are able to recognize useful system organization. This include: pipes and filter- this is where the pipe which is considered as an input is connected to the filters (output), data abstraction- provides useful ways that can be used to organize a particular software, Layered system- is a system that is arranged in a hierarchically, rule-based system-this occurs where computation is organized, and each one of them gives a rule which it operates and when it does apply, last but not least is the blackboard system- this is where the central data represents the existing state of computation, each one of them is responsible for certain update, check of the existing state and it is responsible for receiving certain knowledge .

Another significant point made by shaw in relation to software architecture is basically based on ruled-based system.

Read More