Portability in high-level computer programming is the usability of the same software in different environments. The prerequirement for portability is the generalized abstraction
between the application logic and system interfaces. When software with the same functionality is produced for several computing platforms, portability is the key issue for
development cost reduction. This article is about portability in itself. The work required to make software portable is described in the article on porting.

Strategies for portability

Software portability may involve:

  • Transferring installed program files to another computer of basically the same architecture.
  • Reinstalling a program from distribution files on another computer of basically the same architecture.
  • Building executable programs for different platforms from source code; this is what is usually understood by “porting”.

Similar systems
When operating systems of the same family are installed on two computers with processors with similar instruction sets it is often possible to transfer the files implementing a program files between them.

In the simplest case the file or files may simply be copied from one machine to the other. However, in many case the software is installed on a computer in a way which depends
upon its detailed hardware, software, and setup, with device drivers for particular devices, using installed operating system and supporting software components, and using
different drives or directories.

In some cases software, usually described as “portable software” is specifically designed to run on different computers with compatible operating systems and processors without
any machine-dependent installation; it is sufficient to transfer specified directories and their contents. Software installed on portable mass storage devices such as USB sticks can
be used on any compatible computer on simply plugging the storage device in, and stores all configuration information on the removable device. Hardware- and software-specific
information is often stored in configuration files in specified locations (the registry on machines running Microsoft Windows) Software which is not portable in this sense will have to be transferred with modifications to support the environment on the destination machine.

Different operating systems, similar processors
When the systems in question have compatible processors (usually x86-compatible processors on desktop computers), they will execute the low-level program instructions in the same manner, but the system calls are likely to differ between different operating systems. Later operating systems of UNIX heritage, including Linux, BSD, Solaris and OS X, are able to achieve a high degree of software portability by using the POSIX standard for calling OS functions. Such POSIX-based programs can be compiled for use in Windows by means of interface software such as Cygwin.

Different processors
As of 2011 the majority of desktop and laptop computers used microprocessors compatible with the 32- and 64-bit x86 instruction sets. Smaller portable devices use processors with different and incompatible instruction sets, such as ARM. The difference between larger and smaller devices is such that detailed software operation is different; an application designed to display suitably on a large screen cannot simply be ported to a pocket-sized smartphone with a tiny screen even if the functionality is similar.

Web applications are required to be processor independent, so portability can be achieved by using web programming techniques, writing in JavaScript. Such a program can run in
a common web browser, which as of 2011 can be assumed to have a Java package containing the Java virtual machine and its Java Class Library. Such web applications must, for security reasons, have limited control over the host computer, especially regarding reading and writing files. Non-web programs, installed upon a computer in the normal manner, can have more control, and yet achieve system portability by linking to the Java package. By using Java bytecode instructions instead of processor-dependent machine code, maximum software portability is achieved. Programs need not be written in Java, as compilers for several other languages can generate Java bytecode: Jruby does it from Ruby programs, Jython from Python programs, and there are several others.

Software can be recompiled and linked from source code for different operating systems and processors if written in a programming language supporting compilation for the platforms. This is usually a task for the program developers; typical users have neither access to the source code nor the required skills.

In open-source environments such as Linux the source code is available to all. In earlier days source code was often distributed in a standardised format, and could be built into
executable code with a standard Make tool for any particular system by moderately knowledgeable users if no errors occurred during the build. Some Linux distributions distribute software to users in source form. In these cases there is usually no need for detailed adaptation of the software for the system; it is distributed in a way which modifies the compilation process to match the system.

News About Software portability:
Portable Applications Becoming More Popular
Computer scientist seeks to improve portability of mobile device
What is a portable application, and why should you use them?

This entry was posted in Software Portability. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s