When starting to learn Java as your first coding language, you would inevitably need to learn a number of basic fundamental things about programming and software development. One of them is programming paradigms and differences between them.
Functional Programming and Object-Oriented Programming are the two paradigms, or styles, of programming, that we are going to take a look at today, trying to understand what they are all about and how functional programming and OOP are different. Knowing programming paradigms would be an important piece of that fundamental theoretical knowledge that any serious programmer needs, especially if he/she is aiming for a long-term career in software development.
What is a programming paradigm?
But in order to get an understanding of the differences between OOP and functional programming (FP), we really need to start from basics here and clarify what a programming paradigm actually is.
The programming paradigm is a way to classify coding languages based on their features, which, combined together, form a paradigm or a style, a particular way of computer programming. A number of features determine a programming paradigm, including objects, control flow, modularity, interrupts or events, etc.
And just as it is with coding languages, every programming paradigm has its own pluses and minuses, pros and cons, strengths and weaknesses, which you should take into account when picking a language for the project that you have in mind.
What is OOP?
Object-oriented programming (OOP) is a conceptual programming paradigm that uses objects as the key. In this model, objects are used to represent things that you are programming. You can also say that OOP uses abstraction to create models based on the real world.
Many popular programming languages support OOP, including Java, C++, Python, and PHP. A number of techniques from other previously established programming paradigms are a part of OOP, like modularity, polymorphism, encapsulation, abstraction, and inheritance.
What is functional programming?
Functional programming is also a programming paradigm, which focuses on evaluating functions and developing the structure of program code, ultimately avoiding any changing states and mutable data. Functional programming is about evaluating expressions to make sure the output of a function is the same, in the case when the same exact inputs to the function are given.
There is a number of functional languages out there, with the most popular and widely used being Common Lisp, Scheme, Clojure, Wolfram Language, Erlang, Haskell, and others. There is also a number of languages that support functional programming or have some implemented features from this paradigm. C++, Python, Scala, PHP, Kotlin, and Perl are among them. Functional programming is also very important in some scientific and other specialized languages, like R in statistics, XQuery/XSLT for XML, or J, K, and Q in financial analysis.
Comparing OOP and functional programming
That explanation didn’t help much, did it? Let’s try to look at this from a more fundamental perspective. What are the main basic components of any computer program? They are data
(what the program is allowed to know) and programmed behavior
(what it is allowed to do with this data).
What is the key difference in the way OOP and FP are approaching computer programming? Well, the way OOP is using relies on combining data and behaviors related to that data into one place, which is called “object.” Using objects allows programmers to simplify the way their programs work. Functional programming on the other hand states that data and behavior should remain two different things and not be separated for the overall clarity, easily understandable code, and higher code reusability.
Differences between OOP and FP
To make the differences between OOP and FP as clear as it is possible (in one relatively short article), let’s try to specify the main differences between these two paradigms one by one.
1. Concept and definition.
OOP is based on the concept of objects as an abstract data type created by a developer, can include multiple properties and methods, and may even contain other objects.
FP’s core emphasis is on the evaluation of functions, with each function performing a specific task.
2. Fundamental elements.
Fundamental elements in OOP are objects and methods, with mutable (can be modified after it was created) data used.
In FP, functions and variables are the fundamental elements, while the data in functions is always immutable (cannot be modified after it was created).
3. Programming model.
OOP follows the imperative programming model.
FP follows the declarative programming model.
4. Parallel programming.
OOP does not support parallel programming.
FP supports parallel programming.
5. Statements order in execution.
In OOP, statements need to follow an order in line with the specified approach while execution.
In FP, statements do not need to follow any particular order while execution for it to be successful.
6. Access specifiers.
OOP languages have three access specifiers (keywords that set the accessibility of classes, methods, and other members): Public, Private, and Protected.
FP-based languages do not have any access specifiers.
7. Flexibility and adding data/functions.
Flexibility is one of the core strengths of OOP languages as they provide an easy way to add new data and functions to the existing program.
With FP languages, adding new things to your programs is less convenient and more complex.
8. Data hiding and security.
Security is another advantage of object-oriented programming as OOP languages support data hiding, which ultimately allows creating secure programs. We were talking about why Java is considered to be a safe language (and if this is entirely true) in a separate article
, by the way.
With functional programming, data hiding is not possible, which is a big obstacle on your way if you are looking to develop a secure program with FP language.
OOP vs FP. Which is better?
So, if the OOP programming paradigm gets into a fight against FP, which one would win? This is a joke question, obviously. But if it wasn’t, we would definitely bet on OOP kicking FP’s ass (just because Java is in OOP’s team).
Jokes aside, each of these styles has rather straightforward pros and cons. OOP these days is more common since this style works for large and complex projects much better. Objects and methods are normally easily understandable, which makes OOP programming relatively easy to master even for complete beginners. Generally, object-oriented programming works really well in the back end development, because when you are working across a number of different systems and platforms, OOP allows you to pack everything up (into an object) and keep it secure from any unauthorized party. Lower code reusability and potential unexpected side effects and impacts on processes that OOP code may have, are among the main disadvantages of the OOP model.
Functional programming, on the other hand, is good when the complexity is contained and specified, so FP can often be used in the front end development where clean code and transparent functions are more important, allowing you to achieve a reliable performance without unexpected side effects. When it comes to the development of complex systems that would potentially need extensive scaling, FP is less effective and applicable compared to OOP.