Object-Oriented Languages
Object-Oriented programming (or OOP) is an approach to programming that perceives the real life as a collection of objects that work in conjunction with one another to solve a problem.
One of the main points of Object Oriented programming is the idea that each object that comprises the program is self-sustaining, meaning that all of the components that make up that are within the object itself. This concept is what is referred to as encapsulation.
Due to the fact that each module within the paradigm is self-sustaining, objects can be taken from one solution or program entirely, and used to solve another problem or program with very little, if any, modification. Much like in real life, an object is always an object, although its function can be used to accomplish a multitude of tasks.
The advantages of Object-Oriented languages include:
- Ease of management. This is due, in part, to the fact that Object Oriented programming incorporates modularity. Since each object within the program is complete within itself, it is easier to locate and correct a problem within a module, than it is search an entire program of intertwined code.
- Understandability. Object-Oriented languages mimic the real world; and therefore, make them easier to grasp.
- Re-usability. As stated, an object is a whole within itself. This means that one can remove the need to "recreate the wheel", and rather "beg, borrow, and steal" objects to be incorporated into other programs.
The disadvantages of Object-Oriented languages include:
- Performance. Object-Oriented programs tend to not only be slower, but also tend to require and use up more memory, than other languages.
- Over-generalization
- Programs that are built using this language tend to take longer to initially create.
Procedural Languages
Procedural Programming, unlike Object Oriented languages, focuses on the steps with which to complete a task, as opposed to the interaction between objects. Procedural Programming breaks down tasks into variables, data structures, and subroutines. These procedures can be called at any given time to carry out its specific function within the programs execution.
The advantages of Procedural languages include:
- Procedural languages are in many cases easier to learn and easier to use(than OOP)
- Procedural languages execute quickly.
- Procedural language code can be reused in various parts of the program.
The disadvantages of Procedural languages include:
- Program code is harder to write.
- Unfortunately, there are no great tools for abstraction and modularization in procedural languages...thus, it is hard to add new functionality or change the work flow without going back and modifying all other parts of the program.
- Procedural code is not easily reusable, so programmers must often recreate the wheel, if the wish to use similar code in another application.
Functional Languages
The Functional Programming paradigm uses mathematical functions. With this, operations are performed based solely based on the inputs into the program, and does not rely on temporary (or hidden) variables in with which to store results between inputs.
The advantages of Functional Languages include:
- Functional Languages provide a protected environment.
- While most programming languages require a considerable amount of state information in order to operate properly, Functional Languages avoid the large amount of code needed to define states.
- Due to functional programming depends only on the arguments input to the function; it does not suffer from side effects.
The disadvantages of Functional Languages include:
- Functional programming can be less efficient than other languages.
- They tend to require a large amount of time and memory.
- Purely Functional Languages are not really used in commercial software development.
Logical Languages
Logical Languages use mathematical logic as a way to solve problems. Within Logical Languages, the programmer ensures that the choices declarative statements. Logical Programming sets boundaries or constraints with which the program can "reason" its way to an output.
The advantages of Logical Languages include:
- Logical Languages are quite reliable.
- Best suited for problems in which knowledge base can be established to come to a solution.
- Programs can be quickly developed as it uses true/false statements, rather than objects, etc.
The disadvantages of Logical Languages include:
- Limited to which types of problems it can efficiently solve.
- The programs execution can be slow.
- True/false statements cannot solve most problems--at all.
With the shift away from the using the web, in favor of Apps, there will continue to be less need to use the web to traverse the internet. Because of this, less and less users are actually pulling up web pages.
The future of programming lies now in the ability to create Apps. Languages that do not allow for the programming of apps will surely take a hit in their popularity of use.
Currently, the language that is mainly used for the creation of iPhone applications is Objective C. Besides this being the obvious language for creating these applications, it is also easier to learn than other languages.
References:
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
http://www.guardian.co.uk/technology/gamesblog/2009/feb/10/gameculture-apple
http://en.wikipedia.org/wiki/Object-oriented_programming
http://en.wikipedia.org/wiki/Procedural_programming
http://en.wikipedia.org/wiki/Functional_programming
http://en.wikipedia.org/wiki/Program_state
www.jsoftware.com/help/jforc/glossary.htm
http://useless-factor.blogspot.com/2007/05/advantage-of-functional-programming.html
Thank you.
ReplyDelete