portability, it is not a matter of definition but more of degree. Some languages and environments are more portable than others.
In the days when computers were contrived, there were many processors and each had its own machine or assembly language. Worse yet, there were no standards for equipment external to the processor such as core-memory and drum memory. Thus most applications were tailored and optimized for one specific computing environment. This is when the demand for
Users of computing machinery (a.k.a. corporations) wanted more computing power and would purchase computers from various manufacturers. The Users also wanted their applications to work on the new computers; either the computer supplier would have to create a similar application or the corporation would hire people to port the application's functionality to the new computer. This became expensive.
Focus On Portability
The thinkers in computer science started working on strategies to reduce the time required to port an application running on one manufacturer's computer (e.g. Honeywell) to another (e.g. IBM). At the same time, the thinkers were becoming lazy and wanted more (machine) code written with less typing and effort. Thus began high level languages.
High level languages focused more on abstract concepts and standardization than the machine language. An application called a translator would convert the high level language to the specialized machine code. This allowed an application to be ported to another platform without minimal changes to the high level source code. In theory, for a new platform, only one translator would need to be written, then many applications (written in the high level language* could be executed on the new platform by running them through the translator. Compilers, and interpreters are specializations of a translator. Applications written in high level languages became more portable than those writing in machine language. Examples: COBOL, LISP, FORTRAN.
Portability and the Environment.
One of the keys to the languages' portability was to avoid or minimize things specific to the processor or environment that were not a part of theoretical computing. Peripherals, such as display terminals, printers and external communications were not standard. Some terminals had 132 character widths while others had 80. A new group of thinkers emerged, developing standards for the environment around the processor. They produced concepts such as ASCII, RS232, HPGL, SCSI, and etc. The peripheral manufacturers started producing products according to these standards. More people were happy. Applications became more portable.
Updating the Languages for Portability.
Some thinkers looked at the old high level languages and decided they needed either updating or reinvention to keep up with the new standards. One of these standards was graphics, which were used for GUIs. By this time, core functionality of graphics was changing less and becoming standardized. So the thinkers created new languages that would have standardized graphics capabilities (along with other features). And again, when creating new languages, other features would be added. The new languages also combined features for producing correct and robust code from the beginning (the language would reduce the possibilities for shooting one's foot). Out of this era came languages such as Java, C++, C#, Perl, Python, Ruby, etc.
These new languages included tighter specifications for portability. As long as the developer stayed within these bounds, the programs would build and execute on different platforms. The more portable languages came up with a solution to the problem of different machine languages: an intermediate executable language (i.e. byte code). The translators would produce and executable in terms of this intermediate executable language. Now applications only needed an interpreter for this intermediate executable language and they could run on a new platform.
Portability is often associated in degree rather than a hard coded definition. Standardization goes in hand with portability. The latest trend is to find ways of making an application's executable more portable across platforms, thus reducing development effort to port an application to new platforms.
When people talk about portability, feel free to question their definition as it applies to the source language or to the executable of the application.