Compilers Determine Language Choice

Intense discussion seem ongoing in the area of deciding which language is the best. Personally, I have used a variety of programming languages since the early 1990s. More than 7 have I used professionally. Another 8 I have used privately or researched. That excludes data transformation and markup languages that I do not consider programming languages. At this writing, only 1 among the programming languages have I used steadily for nearly 15 years in a professional setting. Three others, professional and private, I have used for about 3 years. Throughout that time, I have formed a variety of thoughts about computer programming languages.


When people discuss languages, I believe the discussion is truly about compilers. Directly or indirectly stated, highlighting a language ahead of others is really about the benefits of a language implementation. Programming languages do not work. You can write code all day long. The code will not work.

Code you write does not work. The code file you wrote sits there mindless. A source code file contains a group of statements in a narrow form of human grammar. That source code has to be fed into a compiler to be transformed into actual code the computer runs. After that transformation, you have a program file. The quality of the program is a combination of the directions given in the source code and the quality of the compiler.

Perceived Reputation Among Languages

The properties of a compiler, all the tools that work with the generated program file directly influences the perceived value of the language. Compilers for C and C++ have the highest reputation for performance, power, and programmer control. Interpreted languages are sometimes seems as not having compilers. They do. Part of their appeal is to hide direct use of the compiler, but it is there in the background. The nature of compilers for Java, C#, Ruby, Python, PHP, and Go define the ease of use of those languages. Compilers for functional languages are perceived as giving you the least amount of granular control but the highest level of correctness and accuracy.

C, C++ Reputation Based in Reality

The reputation of C and C++ as the most powerful languages is deserved. Languages such as these have seen others make good on that reputation. C and C++ compilers, depending on the process employed by the person writing code, often sustains that reputation. C and C++ have a major head start over many programming languages besides Fortran and processor specific assemblers in the area of performance and capability. Part of that is due to the many years of intense tuning of the compilers for those languages. The way the languages are defined, greatly benefit their translation through compilers in a way that makes a huge difference.

Interpreted Languages Lag

You can write all kinds of code in an interpreted language. Many constructs exist to make code appear elegant, clean, and highly structured. Little in the syntax of these languages makes them less useful in the areas served by C and C++. There are some differences relevant in systems programming, but the real gap is the compilers typically used. When you run Python code, the usual compiler for it cannot take too long to translate it into actual computer code. You are giving up compiler granularity in exchange for convenience. Situations exist where that convenience is more useful for prototyping or running real world code that works on less intense data.

For example, the JavaScript on a web page typically deals with HTML markup data below a few megabytes. Not the trillions of bytes you might encounter elsewhere in the same process. That larger data may enlist the capabilities of C, C++, or other languages whose compilers paired with appropriate program structures and systems organization would allow such data to be more effectively processed. Ultra small dribbles of which can be siphoned out for visualization on a web page that can handle the super small slices.

The right compiler at the right place.

True Full Stack Web Development

Given the example in the last section, we now see the nature of web development. The employment of a system of cooperating compilers of either a homogeneous or heterogeneous nature. A system of compilers in which some program components have already been compiled and others are repetitively compiled. That is a meta technical reality that governs full stack web development.

Many Languages, All Defined by Compilation

Multiple, diverse compilers are a practical reality. On the surface, it looks one way. In reality, here is what actually happens.

The compilers that compiled the web browser that in turn has compiler mechanisms for browser languages that call web services. Those web services operating through web servers that are either compiled ahead of time or likewise follows the same repetitive compilation process for code observing the same while accessing databases that are compiled programs that interpret SQL. All of that running on operating systems that are compiled into programs designed to manage other compiled programs.

Besides source code, compilers then serve as the main governing unit. Programs proceed from compilers driven by source code input. Languages then are not the sole thing to understand. Rather, the language and the supporting system of compilers and other tools that all work together to make programs real.

Also, it seems that any Turing Complete language that can access the machine architecture to a first or second approximation can be used to create any other Turing Complete language with some caveats. The caveats can be overcome by the personal liberties taken by the person writing the code. With all the compilers that exist for the various languages, such a process need not occur often. It is however, how new languages become reality.

One Language

Each stack is usually treated by different languages. Could you use one language for it all? Yes, you could. Usually, that means you give up something in the way another language offers in its representational possibilities. Shrewd practitioners of code and designers of systems usually can discern the value of representational qualities forfeited. In practical reality however, it usually means conceding to the qualities of compilers relevant to your situation.

A single language can be used to define the entire stack of software solutions from data to services to visualization. You could gain a more intense level of reuse, optimization, and overall simplification. Often, that is not done as that may exclude possibilities that are seen as valuable in each stack. A data language may be more useful in certain areas. A more pliable language in which the code can be updated more rapidly may be seen more useful in visualization. Something in between pliable and highly structured may be more appealing for creating services. The qualities of the compiler determine the utility of specific languages in each situation.

All About the Compilers

In the beginning, a person may choose a language and be unaware of the role a compiler has in shaping how that language works. A person’s requirements may change and another language is sought. The possibilities that a language’s syntax represent may appeal to a person based on their situation. The reality is that a compiler makes those possibilities real. People don’t really choose a language. People choose compilers.


Leave a Reply

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

You are commenting using your 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

This site uses Akismet to reduce spam. Learn how your comment data is processed.