Computer programming how has it changed since it was discovered?

Answer 1

Computer programming wasn't discovered. You can only discover things that are created by nature or that already exist. Computer programming was invented.

Without programming languages, we'd be forced to program digital computers using the machine's own native language: machine code. Writing machine code is extremely difficult because everything has to be converted to binary. While not impossible, it is highly repetitive, laborious and prone to error. Moreover, the code for one machine was specific to that machine's architecture. If we wanted to run the same program on another machine with a different architecture, we had to start from scratch. However, for many years, that is precisely what we did because keyboard-entry systems simply didn't exist; everything had be encoded manually by setting banks of switches or by punching holes in chains of cards.

Keyboard-entry systems brought about the second generation of programming languages that became known as assembly languages. These languages were low-level, machine-specific symbolic languages, however we no longer had to convert everything to binary, the computer could do that for us using a simple translation program known as an assembler. Each assembly instruction mapped 1:1 with a specific instruction within the machine's instruction set. Numeric data (such as memory addresses) could be encoded in decimal, hexadecimal, octal or binary itself. Although the programming was still quite primitive and difficult to read, human-readable comments written in plain English that were ignored by the assembler could be included in the code itself, thus making it much easier for code maintainers to follow the logic of another programmer's code (as well as their own!).

Assemblers made it possible to create more complex programs and one of the earliest of these programs was known as a compiler. This was capable of translating a more complex, third-generation, high-level symbolic language where each individual statement could be translated into dozens of individual assembly instructions. The languages became more human-friendly, more English-like, and could be constructed such that the same source code could be compiled by different compilers to produce binary encodings for a wide variety of machine types and architectures. Programming was no longer machine-specific -- it was portable!

These newer languages made it possible to write ever more complex compilers for ever more complex languages, introducing modular programming, functional programming, structured programming, object-oriented programming and so on. Each new language borrowed ideas from existing languages, combining them, enhancing them, making them easier to use.

Along with compiled languages, interpreted languages were also created. Interpreted languages are not compiled into machine code, rather they are translated while they execute. Interpretation speeds up the development cycle because programmers no longer have wait for a program to fully compile before it can be tested (which could many minutes or even hours for large programs), they can simply code and run, and even modify code while it is running! Interpreted languages are not as fast as the native-machine code programs produced by compilers, but they help to quickly test new ideas before committing to a compiled language. Although compiled languages produce the fastest code, the code is machine-specific and must be compiled separately for each supported platform. Interpreted languages are interpreted at runtime and are therefore much easier to distribute, however the source code is exposed for all to see.

Modern languages like Java and C# are both compiled and interpreted. Interpreting high-level instructions is a time-consuming process which adversely affects performance. But by compiling the high-level code to an intermediate encoding known as byte code, the code becomes much easier to interpret without sacrificing portability. The byte code can also be obfuscated to provide better protection to intellectual property -- the software itself.