Numiton

NOTE: To use the advanced features of this site you need javascript turned on.

Home Knowledge Base Software Translation Software Migration

Software Migration

The evolution of programming languages has produced a wide variety of exponents, grouped into generations. Evolving computer hardware together with evolving operating systems have led to the emergence of new programming languages and to the marginalization of others. As a consequence, the allotment of specialists in different programming languages and architectures has changed over time. A programming language doesn’t disappear, but once there are no tools to run it on new platforms, the language is less and less used and specialists are increasingly more difficult to find. This is the case of many COBOL dialects, for example.

Another cause of language outdating is that in time their features cover less and less of the current needs – lack of Web support is an example in this sense. That is why new and improved versions should be continuously developed for languages, their libraries and tools. When this does not happen, possibly because the vendor is out of business, some languages do get to a dead point.

In such situations it becomes necessary to migrate application systems developed with outdated languages towards modern languages and technologies, more adequate for business needs and with support from established vendors. The migration process also offers the possibility of switching the underlying hardware and software platform (e.g. migration from mainframes to PCs).

Programming languages have evolved in the sense of increased organization of the source code, which is important both from a software development and from a maintenance point of view. As an example let's consider the linear code in a fictional L language:

 

decl crtCode=1
decl val=0
decl price
decl quantity

goto computeValue
displayValue: display val
goto end

computeValue: cond crtCode<=finalCode
goto computeCrtCode
priceComputeReturn: goto computeQuantity
quantityComputeReturn: val=val+price*quantity
crtCode=crtCode+1
goto computeValue
else
goto displayValue

end:

 

The same code would look as follows when using a structured language:

 

func computeValue(startCode, finalCode)
decl val=0
loop(crtCode=startCode;crtCode<=finalCode;inc(crtCode))
val+=computePrice(crtCode)*computeQuantity(crtCode)
return val

procedure displayValue(startCode, finalCode)
display(computeValue(startCode,finalCode))

 

Label-based unconditional jumps disappear by using constructions that suggest a natural execution flow.

The same source code can be re-written in an object-oriented language as follows:

 

object Value
private decl val
private decl startCode
private decl finalCode

public constructor(sc,fc)
startCode=sc
finalCode=fc

public method displayValue()
display(computeValue())

public method computeValue()
decl val=0
loop(crtCode=startCode;crtCode<=finalCode;inc(crtCode))
val+=computePrice(crtCode)*computeQuantity(crtCode)
return val

 

Protection levels may be applied to the object members, in order to restrict communication and especially means of altering values within the object. Also, by using the inheritance and encapsulation mechanisms, the result is a simpler description of the program structure.

Once the need to migrate an application has been established, a matter to be thoroughly considered is that of the target language. The most suitable type of language is usually a general-purpose one, with high expressivity, well-supported by vendors. The available tools should be sophisticated enough to allow efficient control over the code base. Finally, the specialists with a suitable skill degree should be readily available.

While this migration can be accomplished manually by a complete rewrite of the application system, there are situations when an automated process is more suitable. Automated migration is performed using specialized products called software migrators.

A software migrator is a complex tool that automatically translates application systems written in a source language into semantically equivalent applications that use a different (target) language.