Subscribe by Email


Showing posts with label Software Re-engineering. Show all posts
Showing posts with label Software Re-engineering. Show all posts

Monday, June 18, 2012

How is data understood through reverse engineering?


Reverse engineering forms an internal part of the whole software re- engineering process. To implement the reverse engineering properly in the re- engineering process one needs to understand the data through the reverse engineering.
In this article we have taken up the same topic i.e., “how is data understood through reverse engineering?” 
- When the reverse engineering is carried out, the main objective is always to recover the designs and specifications of the software system or application.
- With reverse engineering, the development is only understood and no changes are made to the software system or application. 
- For the reverse engineering process, the source of the software system or application is fed as the input. 
- If you go through the history of the reverse engineering, you will find some cases where the executable code is given as input for the reverse engineering process. 
- The reverse engineering though being in a great contrast with the re- engineering forms an internal part of it. 
- Reverse engineering serves the purpose of recovering system design and specifications in the software re- engineering process model. 
- These recovered designs and specifications are used by the engineers to understand the software system or application before they start re- organizing the whole structure.
- However, there have been cases in which the reverse engineering is not always followed by the re- engineering process. 
- There are three stages in reverse engineering process.
 1. System to be re- engineered is subjected to automated analysis.
 2. Then it is manually annotated.
 3. With the system information obtained, a whole set of new documentation is generated containing:
(a)  Program structure diagrams
(b)  Data structure diagrams and
(c)   Traceability matrices.

Activities in Reverse engineering


In reverse engineering the data is understood by the 3 basic activities that involved intense understanding efforts:
1. Understanding process: In order to understand the procedural abstractions as well as functionality analyze the source code on the level:
(a)  System
(b)  Program
(c)   Component
(d)  Statement and
(e)  Pattern

2. Understanding data: It analyzes the internal data structures and data base structure.
3. User interfaces: It analyzes the basic actions processed by the interface, system’s behavioral response to those actions and equivalency of the interfaces.

More about reverse engineering....
- The beginning of the reverse engineering process is marked with an analysis phase in which the analyzation is carried out with the help of automated tools in order to discover the structure of the software system or application. 
- But this stage itself does not suffice the purpose of recovering the whole structure. 
- Engineers then have to work on the program code and model and add the recovered information to this.
- The recovered information is maintained in form of a directed graph. 
- The engineers always make it a point to link the directed graph to the source code. 
- The directed graphs are compared with the code with the help of the information browser stores. 
- This graph helps in generating trace ability matrices and the data structures. 
- Tools that are used make it easy to navigate through the code. 
- After the complete generation of the design documentation, the information store is supplied with the additional information as a measure to re create the specifications systems. 


What is meant by Software Reengineering Process Model?


Software re- engineering process model is based up on the principles of the software re- engineering that was proposed by Chifosky in the year of 1990.  Before we discuss about the software re- engineering process model let us see what software re- engineering is.

What is Software Re-engineering?


- The software re- engineering is considered to be a process that alters a software system and thus reconstituting it in to a new form that is better than its previous form.
- The process of the re- engineering usually occurs after the software system or application has been reverse engineered. 
- The re- engineering is also carried out for the addition of the new functionalities or to correct the discovered faults and errors. 
- Sometimes this whole process is often collectively called as reverse engineering. 
But there is a subtle difference between the two! 
- The former process i.e., the reverse engineering is like an initial examination of the software system and the latter is like the subsequent modification. 
- Re- engineering of the software systems often comes in to play where there is an involvement of a legacy system. 
- In such cases the re- engineering can be considered to be a process that re- structures a legacy system in to a new system that is constituted of much better features and functionality and maintain the quality constraint.

Re- engineering is not a thing that can be achieved in an instant rather it takes a lot of time since there is a utilization of many information technological resources over the years. Therefore every organization requires a well defined strategy for carrying out the software re-engineering. 

Steps in Software re-engineering process model


The software engineering process model consists of the following steps:
1.Inventory analysis: Analysis of all the active applications listed in the inventory of an organization.
2.Document reconstruction: The software systems that are business critical are re- documented.
3. Reverse engineering
4. Code restructuring: It involves the analyzation of the source code and reviewed again.
5. Data restructuring: It begins with reverse engineering and ends with the review of all the data structures.

Scenario behind software re-engineering process
- Software re- engineering process serves the purpose of bringing up the poorly documented and poorly structured code to a standard that is maintainable and acceptable. 
- Let us see the scenario behind the need of re- engineering. 
- In a code that is poorly controlled and maintained, lies either a large number of files spread over a number of locations or consists of only a single file consisting of a very lengthy code.
- Observing these files, one could notice that the comments do not appear to have any relationship with the code itself and the associated documentation has become outdated or refers to the previous versions of that software system or application that has underwent many modifications since then which were left undocumented. 
- To say, an executable file does exists but many decisions have to be taken to run it. 
- At this point the identification of the actual objectives of the software re- engineering process becomes important. 
- There might be so many problems underlying those decisions that now can be easily addressed. 
- It is very important that before beginning with the re- engineering of the whole code that you check its correctness otherwise you will suffer a major set back if you would have been re- engineering the wrong code all the time. 
- At the end of the process the final code needs to be base-lined with the associated project log and the documentation.
- The re- engineered software system or application is brought to a well defined stage at which it can be considered to be ready for the release and also its future maintenance will be less arduous.


Sunday, June 17, 2012

Forward Engineering - An activity involved in software re-engineering process model


The Software re- engineering process model is known to follow a series of 6 major steps namely:
  1. Inventory analysis
  2. Documentation reconstruction
  3. Reverse engineering
  4. Code re- structuring
  5. Data re- structuring
  6. Forward engineering
In this, we are going to discuss in detail the last step of the software re- engineering process model i.e., the forward engineering. So let us see what this forward engineering is and what role it has got to play in the software re- engineering process. 
As we know the need for re- engineering a software system or application is felt when the software system becomes obsolete to be maintained and executed. 

About Forward Engineering


- Forward engineering follows up after the completion of the data re- structuring. 
- The forward engineering is also known as:
  1. Renovation or
  2. Reclamation
- The forward engineering is carried out so as to recover the design information from the code that already exists. 
- This design information is then used in the re- constitution of the already existing software system or application for improving its overall performance and quality as well.

Stages in Forward Engineering


The forward engineering makes progress by the means of the following stages:
  1. Identification of the system specifications.
  2. Designing and implementation of the specifications.
  3. Creation of a new software system or application.

Characteristics of Forward Engineering Client or Server


A forward engineering client or server architecture has got the following characteristics:
  1. The client computer accepts the migrated application functionality.
  2. At the client sites the new GUI interfaces are implemented.
  3. The data base functions are allocated to the servers.
  4. In some cases the specialized functionality may preside at the site of the server itself.
  5. There are certain requirements like communications, archiving, control and security requirements that are established at both the server as well as the client side.

Forward Engineering in OOA


- In object oriented architectures under the concept of the forward engineering, the existing software system is subjected to reverse engineering so that an appropriate model is created. - The user interfaces developed with the forward engineering tend to understand the original user interface and data flow between the interface and the rest of the software application. 
- The behavior that was implied by the already existing user interface is re-modeled in to a series of GUI context abstractions.
- Also, the improvements with which the mode of interaction can become more efficient are introduced during the forward engineering.
- Furthermore, the new graphical user interface is built and integrated in to the re- engineered software system or application.

Difference between Forward Engineering & Software Re-engineering


- Forward engineering is a type of a traditional process in which the logical and high level abstractions are moved to the physical implementation of the software system or application. 
- The conventional development was named as forward engineering by Chikosfy and Cross in order to distinguish it from the software re- engineering process. 
- The basic difference between forward engineering and software re-engineering is that the former starts with the system specifications while the latter starts with an existing system and the whole process revolves around the transformation of the original system. - What is given as input is a legacy system and what comes as output is a modularized and structured version of that program. 
- The cost of the forward engineering depends on the extent of work that has been done. 
- There are several other factors that affect the cost of the re- engineering:
  1. Extent of data conversion required
  2. Tool support available
  3. Quality of the software system to be re- engineering


Data Restructuring - An activity involved in software re-engineering process model

Software re- engineering process model constitutes of the below mentioned 6 major  steps:
  1. Inventory analysis
  2. Documentation reconstruction
  3. Reverse engineering
  4. Code re- structuring
  5. Data re- structuring
  6. Forward engineering
In this article we have discussed about the 5th stage of the software re- engineering process model i.e., the data re- structuring. 
Without a working code or an active flow of data a software system or application cannot be considered to be working. Therefore for the software systems and applications which have become outdated should be again brought up to the current acceptable software standards and data re- structuring is the one of the processes that can help in this regard. 


- This step of software re- engineering process model takes into consideration the restructuring of the data without making changes to the functionality of the software system or application. 
- With the re- structuring of data, the maintenance of the whole software system or application becomes so very easy. 
- The need to re- structure data arises when the data bases become too obsolete to be handled directly. 
- When the changes made to the data are confined only to the sub system, the data of the sub system needs to be re- structured. 
- The data re- structuring becomes even easier when the data re- structuring tools are easily available. 
- This step is carried out after the completion of the code re- structuring. 
- Unlike the previous re- structuring step, this step calls for a full cycle of reverse engineering. 
- The current structure of the data is dissected while defining the data models and the existing data models are run through a quality check or review test.
- So many of the legacy systems tend to make use of the global data structures and shared tables in order to save the memory space.
- Such shared data structures need to be converted in to objects like ADTs for restructuring. 



Benefits of Data Re-structuring


- One of the benefits of restructuring the data is that it certainly improves the quality of the software program or application. 
- Furthermore, it becomes easier to test and debug the software system or application along with a reduction in the efforts in the maintenance of the software and also the frustration of the developer is reduced. 
- As a bonus point, the productivity is also improved. 



Steps in Data Re-structuring


The re- structuring of the data involves the following steps:
  1. Analysis of the source code of the application.
  2. Redesigning of the data
  3. Standardization of the data record.
  4. Rationalization of the data name.
  5. Translation of the file or data base.

Drawbacks of Data Restructuring


In spite of having so much plus points, the re- structuring does have some minus points which have been listed below:
  1. Re- structuring does not improve the understandability of the data driven programs.
  2. Re- structuring demands for heavy computations.
  3. Re- structuring can lead to a loss of source code comments.
  4. Restructuring does not helps with the problems with poor modularization i.e., the programs in which the components are wide spread through out the program.
  5. Restructuring can lead to the loss of documentation.
From the discussion above, we can say the restructuring of data is a process that re –structures the source data in to the target data during the transformation process. 
Data re- structuring forms an integral part of the software re- engineering process model and therefore the above mentioned disadvantages of the data re- structuring are ignored. It is necessary that the data re- structuring is carried out after the code re- structuring since during the execution of the program, the code only handles the flow of the data. Therefore if the code itself has not been re- structured before re- structuring the data then the whole process does not makes any sense. 


Saturday, June 16, 2012

Code Restructuring - An activity involved in software re-engineering process model

As we know “Software re- engineering process model” is a model that has been used over the years to improvise the already existing poor code that is no longer accepted.  The poor code is restructured to meet the current standards of software engineering. This model consists of 6 basic steps as mentioned below:
  1. Inventory analysis
  2. Documentation reconstruction
  3. Reverse engineering
  4. Code re- structuring
  5. Data re- structuring
  6. Forward Engineering
This article is dedicated to the discussion regarding the fourth stage of the software re- engineering process model i.e., the code reconstruction. 



What is meant by Code Reconstruction?


- The code restructuring process involves analyzation of the source code. 
- The violations of the programming practices are noted down and later repaired. 
- The revised code is then reviewed and subjected to extensive testing. 
-Firstly, in this stage the program files that are executable are identified with the consultation of the person in the company who is intimate enough with the knowledge of the files and can grant some logic to their existence. 
- Next step, in this stage is the verification of the identified and setting up of the baseline. 
- This step requires a lot of investigative work since the executable might have been affected by a lot of factors. 
- The code is verified using the sample input data or test files.
- The baseline for the executable is formed by documented data files and source code files. 
- Now the developer who holds the responsibility to re- engineer the code, needs to familiarize himself with the existing code and figure how is going to re- engineer it. 
- He then carries out several walk-throughs and code reviews under many different conditions with its users.
- At this stage, the developer is free to introduce comments in to the code as per its re- structuring needs.
- Other requirements can be stated in the project log. 
- It is very common for the developer to encounter bugs at this stage. 
- The developer needs to discuss with the client and figure out a way of dealing with the bugs. 
- Next follows the identification of the requirements of the process like:
  1. Commenting the code.
  2. Modularity of the code.
  3. Documentation of the code.
  4. Enhancement of the code.
  5. Removal of the unused or unnecessary code.
  6. Removal of the duplicate code.
  7. Removal of duplicate parameters.
  8. Porting of the code to another platform.
  9. Enhancement of the user interface.
  10. Defining the language standard of the code.
  11. Conversion of the code in to an alternative development language.
  12. Improvement and maintenance of the performance.
  13. Optimization of the code.
  14. Improvising the internal error handling capacity of the code.
  15. Inclusion of additional functionality.
  16. Fixing the existing bugs.
  17. Implementing alternate third party products.

More about Code Restructuring


- The code is restructured in identifiable phases i.e., the original code is re- engineered in the phases that have been identified. 
- The software tools here may be helpful in the investigation of the code coverage, unused variables, hot spots, coding standards and so on. 
- Apart from these, manual inspections can also help a big deal in identification and removal of the duplicated and false code, collate parameter definitions and optimize the array storage. 
- On an overall basis, restructuring of the code greatly improves its performance. 
- Even the simplest of the “not so obvious” issue can significantly affect the performance of the code like accessing of the data. 
- Different languages have their own way of storing arrays. 
- Therefore, the way that is used to access this data can hamper the performance to a great extent without coming to the knowledge of the developer. 
- Lastly, the code is tested after the completion of the restructuring. 


Reverse Engineering - an activity involved in software re-engineering process model.


Software re-engineering process model is a very generic process meant to uplift the standard of the poor code that is currently not acceptable. This model is known to have 6 major stages namely:
  1. Inventory analysis
  2. Documentation reconstruction
  3. Reverse engineering
  4. Code re- structuring
  5. Data re- structuring
  6. Forward Engineering
This article is all about the third stage i.e., “reverse engineering” which is an important concept in itself. 
Re- engineering is usually required when the some of the sub systems of a larger software system or application need to frequently maintained. The re- engineered system is then restructured and re- documented. 

What is Reverse Engineering?


- The reverse engineering forms a very important factor in success of the re- engineering process. 
- The reverse engineering can be considered to be a process of recovering the design of the software system or application that is to be re- engineered. 
- This step involves analyzation of the software program in an effort to obtain an abstract level representation of the program that is higher than the level of the source code.  
- The software system or application is analyzed in such a way so as to understand its design and specifications and requirements. 
- Reverse engineering is an entirely individual process.
- In some cases the reverse re- engineering may be used  for specifying a software system before it is implemented again. 
- The reverse engineering process makes use of the program understanding tools like:
  1. Browsers
  2. Cross reference generators and so on.

Levels in Reverse Engineering


The reverse engineering process takes effect through the following levels:

1. Abstraction level: The design information of the software system or application is derived at the highest level possible.

2. Completeness: At the above abstraction level, the details of the system are obtained.

3. Interactivity: The degree of the human integration with 5the automated reverse engineering tools is measured.

4. Directionality: It can be either:
(a)  One way: All the extracted information is given to the sogftware engineering who is doing the maintenance.
(b)  Or two way: All the extracted information is fed to a re- engineering tool which then regenerates the old software program.

      5. Extract abstraction: From the old source the processing specifications are obtained.

     

Stages in Reverse Engineering Process


      Reverse engineering process from sommerville goes through the following stages:
      1. System to be re- engineered is subjected to automated analysis.
      2. Then it is manually annotated.
      3. With the system information obtained, a whole set of new documentation is generated containing:
       (a)  Program structure diagrams 
       (b)  Data structure diagrams and 
       (c)   Trace ability matrices.

     

Activities in Reverse Engineering Process


     There are 3 basic activities involved with the reverse engineering process:
   
    1. Understanding process: In order to understand the procedural abstractions as well as functionality analyze the source code on the level:
      (a)  System
      (b)  Program 
      (c)   Component 
      (d)  Statement and 
      (e)  Pattern
    
       2. Understanding data:  It analyzes internal data structures and data base structure.  
   3. User interfaces: It analyzes the basic actions processed by the interface, system’s behavioral response to those actions and equivalency of the interfaces.

When is Reverse Engineering Preferred?


- Reverse engineering is usually preferred when the specifications and designs of the system are required to carry out the program maintenance activities.
- The re- engineering process is preceded by the reverse engineering. 
- To put it simply, the reverse engineering can be thought of as a process that goes back through the whole development cycle.
- UML is a source that supports reverse engineering. 
- Different people have their own different perceptions of the reversion engineering. 
- It can also be thought of as an inversion of the water fall model of software development. 


Facebook activity