What is Programming language ?
A programming language is used to write computer programs such as
- Applications
- Utilities
- Servers
- Systems Programs
A program is written as a series of human understandable computer instructions that can be read by a compiler and linker, and translated into machine code so that a computer can understand and run it.
Type of programming language
1. Low level Language
2. Middle Level Language
3. High Level Language
1. Low level Language
Of all of the categories, it’s probably easiest to define what it means to be a low-level language. Machine code is low level because it runs directly on the processor. Low-level languages are appropriate for writing operating systems or firmware for micro-controllers. They can do just about anything with a little bit of work, but obviously you wouldn’t want to write the next major web framework in one of them (I can see it now, “Assembly on Rails”).
Characteristics
- Direct memory management
- Little-to-no abstraction from the hardware
- Register access
- Statements usually have an obvious correspondence with clock cycles
- Superb performance
C is actually a very interesting language in this category (more so C++) because of how broad its range happens to be. C allows you direct access to registers and memory locations, but it also has a number of constructs which allow significant abstraction from the hardware itself. Really, C and C++ probably represent the most broad spectrum languages in existence, which makes them quite interesting from a theoretical standpoint. In practice, both C and C++ are too low-level to do anything “enterprisy”.
2. Middle Level Language
This is where things start getting vague. Most high-level languages are well defined, as are low-level languages, but mid-level languages tend to be a bit difficult to box. I really define the category by the size of application I would be willing to write using a given language. I would have no problem writing and maintaining a large desktop application in a mid-level language (such as Java), whereas to do so in a low-level language (like Assembly) would lead to unending pain.
This is really the level at which virtual machines start to become common-place. Java, Scala, C# etc all use a virtual machine to provide an execution environment. Thus, many mid-level languages don’t compile directly down to the metal (at least, not right away) but represent a blurring between interpreted and compiled languages. Mid-level languages are almost always defined in terms of low-level languages (e.g. the Java compiler is bootstrapped from C).
Characteristics
- High level abstractions such as objects (or functionals)
- Static typing
- Extremely commonplace (mid-level languages are by far the most widely used)
- Virtual machines
- Garbage collection
- Easy to reason about program flow
3. High Level Language
High-level languages are really interesting if you think about it. They are essentially mid-level languages which just take the concepts of abstraction and high-level constructs to the extreme. For example, Java is mostly object-oriented, but it still relies on primitives which are represented directly in memory. Ruby on the other hand is completely object-oriented. It has no primitives (outside of the runtime implementation) and everything can be treated as an object.
In short, high-level languages are the logical semantic evolution of mid-level languages. It makes a lot of sense when you consider the philosophy of simplification and increase of abstraction. After all, people were n times more productive switching from C to Java with all of its abstractions. If that really was the case, then can’t we just add more and more layers of abstraction to increase productivity exponentially?
High-level languages tend to be extremely dynamic. Runtime flow is changed on the fly through the use of things like dynamic typing, open classes, etc. This sort of technique provides a tremendous amount of flexibility in algorithm design. However, this sort of mucking about with execution also tends to make the programs harder to reason about. It can be very difficult to follow the flow of an algorithm written in Ruby. This “obfuscation of flow” is precisely why I don’t think high-level languages like Ruby are suitable for large applications. That’s just my opinion though.
Characteristics
- Interpreted
- Dynamic constructs (open classes, message-style methods, etc)
- Poor performance
- Concise code
- Flexible syntax (good for internal DSLs)
- Hybrid paradigm (object-oriented and functional)
- Fanatic community
No comments:
Post a Comment