![\"\"\/](\"https:\/\/3.bp.blogspot.com\/-yWASPfKD7ls\/WmrFxDa00VI\/AAAAAAAAPQ0\/RHrtBsIkHqAQVzvCHFNXbsZd_FjbUsm3wCPcBGAYYCw\/s1600\/function_machine.svg.png\")
<\/a><\/figure>\n\n\n\nFunctional Programming<\/strong> (FP) is a programming paradigm<\/a>, mindset, or style of building code in IT world which treats computation or programs as mathematical functions, the so called Pure Functions<\/strong> in computer science. Procedural programming<\/a> also encapsulates codes to the so called procedures which is also often called functions, methods, or routines. However a function as a procedure is not always the same pure function introduced by functional programming since an encapsulations of codes to a function (procedure which is introduced by procedural programming) still can contain side-effect and mutability.<\/p>\n\n\n\n As a mathematical axiom, we can treat a capsulated program as a function: So for a complete requirement of that program, we can treat the requirement as a list of tupels Input and Output, mathematically: By encapsulating code as a pure function (or a function which behaves like a pure function) we can have a best collection set of Input Output Tupels to have an automated test suite which have best test coverage <\/em><\/p><\/blockquote>\n\n\n\n Since functional programming uses the concept of pure functions, the function \/ the part of the code which is encapsulated as a pure function can be easily moved to other place as a black box for re-usability or for the purpose of code readability without any huge effort of refactoring like in case we use a lot of side effects in the codes. Do you want to have short classes for your whole codes? Have a look to adoption of functional programming in OOP to encapsulate codes as black-boxes.<\/em><\/p><\/blockquote>\n\n\n\n The concept of functional programming is by letting us pass anything as input parameter. We pass each input parameter which causes any effects of the outputs. It includes to pass behavior as parameter, in other words it let us pass a function as an input parameter of the main function (high-order function<\/a>). Since functional programming minimize side-effects, avoid shared variables, and mutability in its concept which make the implementation thread-safe based on the purity of the function’s implementation, it becomes more natural for functional programming for parallelization, multi-threading, or multi-core processing.<\/p>\n\n\n\n Functional Programming is a concept and paradigm, we can adopt it to any programming language. However how far or how complete we can adopt, it depends on the functional programming support for the particular programming language. Besides the pure function concept the functional programming paradigm as I mentioned before has a lot of introduced other concepts to support the pureness. By understanding the concept of side-effects we try to maintain them not to have dirty unpredictable side-effects and use it whenever necessary.<\/p>\n\n\n\n As a conclusion, I would say that functional programming concept and paradigm bring a lot of benefit in code development. Use it wisely to know where and when to adopt for each concept. – By Efelti<\/p>\n\n\n\n Background Functional Programming has become a hot topic. Either developers talk about testable codes, modularization, lazy loading, or multi-threading \/ parallelization, functional programming often becomes a topic into the discussions. What is actually functional programming? What is Functional Programming Functional Programming (FP) is a programming paradigm, mindset, or style of building code in IT world which treats […]<\/p>\n","protected":false},"author":1,"featured_media":9,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[2,3],"class_list":["post-8","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-clean-code","tag-clean-code","tag-functional-programming"],"_links":{"self":[{"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/posts\/8","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=8"}],"version-history":[{"count":1,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/posts\/8\/revisions"}],"predecessor-version":[{"id":10,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/posts\/8\/revisions\/10"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=\/wp\/v2\/media\/9"}],"wp:attachment":[{"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=8"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=8"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/efelti.com\/tech\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=8"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
A pure function itself is a function where the output only depends on the input. Shortly explain: we treat a code or a program as a function f(x). The input is \u201cx\u201d, \u201cf\u201d is the function or how the code behaves, and \u201cy = f(x)\u201d is the output. The result \/ output \u201cy\u201d only depends on \u201cx\u201d and not anything else. Whenever the function is executed with same input \u201cx\u201d, it always produces the same output \u201cy\u201d, it does not matter how many times we execute it, does not matter when we execute it.
By the implication of that principle, it should avoid mutability<\/a> and side effects<\/a>, e.g. global or shared states, or mutable input since those could change the result \u201cy\u201d although we have the same initial input \u201cx\u201d by running the function \u201cf\u201d.
That\u2019s basically one of the most basic principle of functional programming. There are still a lot of other concepts influence the evolvement of functional programming paradigm. In this article I\u2019ll try to focus not at all but on that principle and see the benefit of it if we consider it and adopt the concept to our development.<\/p>\n\n\n\nProcedural Programming is NOT Functional Programming<\/h3>\n\n\n\n
![\"\"\/](\"https:\/\/4.bp.blogspot.com\/-EODtQWPGw5g\/Wn7Q3HNqRSI\/AAAAAAAAPSg\/9vLwEKblMQYJInfawMXGFxQhPcJAUVg-wCLcBGAs\/s640\/pure%2Bfunction%2Bvs%2Bprocedure.jpeg\")
<\/a><\/figure>\n\n\n\nBenefits of Functional Programming<\/h2>\n\n\n\n
Testable Code (Code Which is Designed for Test Automation)<\/h3>\n\n\n\n
<\/a><\/p>\n\n\n\n
<\/a>
Since in functional programming we treat a program as a function where its output \u201cO\u201d only depends on input \u201cI\u201d, we can create test cases by listing down the tupels (I, O) of test cases. Of course the test completeness will still depends on the testability hierarchy<\/a> of the program but since any input \u201cI\u201d can be passed as the input parameters of the function, we can have the best completeness of the test to have the best code coverage.
This is not always possible if we have side effects which comes from external entities or other layer, since in that case we often do not have controls to modify those side-effects value.
By having it passed through input parameter instead of side effects as a pure function, we could easily mock the parameter, even to mock behaviors as parameters, by the so called high order functions<\/a> (using functions as a parameter).<\/p>\n\n\n\nModularization and Black-Box (Code with Short Methods and Classes)<\/h3>\n\n\n\n
![\"Function](\"https:\/\/3.bp.blogspot.com\/-sIddbe2LddI\/WmrDF7ey77I\/AAAAAAAAPQQ\/0gNNb85UbM8iN8eMwn8X1eOwgIg-hPP-gCEwYBhgL\/s320\/black-box.png\" "\\"Function")
<\/a><\/figure>\n\n\n\n
There are several ways to do pure function in OOP (Object Oriented Programming)<\/a>. An example of it is by using the static method concept to mimic pure function concept. In that approach, we extract method easily to other class, keep classes always short and do what it has to do.<\/p>\n\n\n\nLazy loading<\/h3>\n\n\n\n
The function as an input parameter itself can be run freely inside the main function which take it as parameter. And this is actually the concept of lazy loading<\/a>, by running or invoking the consumed function when we need it.<\/p>\n\n\n\nMulti-Threading \/ Parallelization<\/h3>\n\n\n\n
![\"\"\/](\"https:\/\/2.bp.blogspot.com\/-NHv_hNuivLM\/WmrFbPeSCoI\/AAAAAAAAPQg\/B7t1c0ttfHEdwf28I9e9nClvnbDwb5-VgCLcBGAs\/s320\/parallelization.png\")
<\/a><\/figure>\n\n\n\nFunctional Programming Features in Programming Languages<\/h2>\n\n\n\n
Here is a list of some most used interesting features we could check, if we want to start doing functional programming paradigm into the particular programming language.<\/p>\n\n\n\n
Important support for functional programming in programming language is the higher order function. A language which support this by its prioritization is called first class function<\/a> of programming language, to have possibilities to pass function as parameters, to return function as the output, or to have data value as a function.<\/li>
Higher order function are often implemented in programming languages as Lambda expression<\/a> to pass an anonymous function<\/a> as parameter. Checking that feature might be useful.<\/li>
For language which is weakly typed<\/a> (not strongly typed<\/a>) like JavaScript. Passing parameters to function is easier since every kind of types including function type can be done without additional effort. For language which is strongly typed like C# or Java or even TypeScript, another approach is to be taken. In C# or TypeScript dynamic type modifier is used to make it weakly typed (“dynamic<\/a>” in C# or “any<\/a>” in TypeScript). Or we could also use Generic Programming<\/a>, to make the parameterization still strongly typed whenever we pass a function contract as a parameter.<\/li>
Sending a function as parameter also could be done by using interface concept<\/a> as work around in case we do not have the feature to send a function directly as a parameter, e.g. working with Java 7 or prior version. Basically the function contract will be encapsulated within an interface. The input parameter contract will contain only the interface, and the real value to pass is the implementation class of that particular interface.<\/li><\/ul>\n\n\n\nAdopting Functional Programming Paradigm<\/h2>\n\n\n\n
The functional programming paradigm itself has been evolving from the declarative programming paradigm<\/a> which uses the concept of declarations \/ expressions over the statements concept introduced by imperative programming<\/a>. It puts more focus in structures instead of the execution orders. Not like in the imperative programming, the functional programming prefers to use recursion structures<\/a> over iteration loops<\/a>.
There are several levels how we could adopt functional programming in the development. The extreme one might be the purely functional programming<\/a> where it tries to adopt the full concept of functional programming and avoid side effects and mutability completely.
However, not all of the concepts are really 100%-ly dependent one to each other that avoids us to adopt one and try not to adopt the others. Also there are always benefits and drawbacks of each concept introduced by the functional programming. Putting everything together and try to do everything without knowing the reason behind it is not always useful, moreover it could even cause problems. Instead we should take what necessary based on what to solve, understand the concept well, and start simple.
For instance, even of the elegance of recursions implementation, implement everything as recursions does not always make sense since recursions could also cause memory problems. That\u2019s why people in many cases should even go for the iterations.
Implementing immutable parameters completely is also not always useful. For example, if your application is single threading and require high performance processing of large amount of data, putting effort to implement pure immutability by replacing mutable data structure which has O(1) algorithm complexity for its operations with the immutable one which has at least O(log n) algorithm complexity does not make sense.
However it might be useful to implement them as a set of functions which have clear definition of inputs and outputs without uncontrolled side-effects, so we would have them behaving as pure functions, and the codes would be more testable also support well for test automations.
However in another scenario in case if you are working for multi-core application. You might need to consider a lot about immutability and how you pass input parameters. And once we could ensure them, it becomes natural that our code fits well for that situation.<\/p>\n\n\n\nConclusion<\/h2>\n\n\n\n
Functional programming helps us to build testable codes. If you are a fan of code with short classes and methods, you should not miss the functional programming. Combining functional programming (FP) with object oriented programming (OOP) paradigm makes your methods encapsulation more maintainable and much more easier for refactoring later.
I personally love functional programming a lot. Functional programming imposes disciplines which help us to create clean and modularized codes, to create testable codes for the support of test automations. I love to combine OOP and FP together embrace their powers and strengths together in code development.<\/p>\n\n\n\nReference<\/h2>\n\n\n\n