This is the 6th article on the System Design and Software Architecture series. In this article, we are discussing the Core objectives and components of Functional programming is an important section in System design and architecture.

Previous articles

What is Functional programming

What is Functional programming
What is Functional programming

Functional programming is a programming model in a structure and component building style of computer programs. That computer programs treat computation as an evaluation of mathematical functions and prevents variable-state and distorted data. This is the process of building software that composes clean tasks, sharing partnerships, preventing distorted data, and side effects. Functional programming is not essential but expressive and the application state flows through clean functions. Unlike the object orientation program, the application status is usually shared and integrated with the object orientation.

Functional programming is a programming model, which means that it is a way of thinking about building software (listed above) based on certain basic, defining principles. Other examples of programming parameters include object-oriented programming and procedural programming.

Functional code is more concise, predictable, and easier to test than essential or object-oriented code.  But if you are unfamiliar with it and the common patterns associated with it, functional code also will more ensembles, and novice literature is invisible to beginners.

If you start googling functional programming terms, you will soon hit a brick wall in academic language. To say that it has a learning curve is a serious understatement. But if you have been programming in JavaScript for a while, you have a good chance of using a lot of functional programming concepts and utilities in your real software.

Characteristics of functioning programming

Characteristics of functioning programming
Characteristics of functioning programming
  • The most prominent features of the active program are as follows –
  • Functional programming languages ​​are designed based on the concept of mathematical functions and use conditional expressions and iterations to calculate them.
  • Functional programming supports high-level tasks and lazy evaluation elements.
  • Functional programming does not support language flow control. Loop expressions and conditional expressions such as if-other and switch expressions. They use direct tasks and active calls.
  • Functional programming languages ​​support popular concepts such as abstraction, encapsulation, inheritance, and multimeter.

Advantages of Functional Programming

Advantages of Functional Programming
Advantages of Functional Programming

Functional programming offers the following benefits –

  • This offers error-free code- Since functional programming does not support the state. Then there are no side effects and we can write error-free code.
  • Efficient Parallel Programming – Functional programming languages ​​do not have a distortion, so there are no state modification issues. One can program “tasks” to work in parallel as “instructions”. Such codes support the ability to be easily reused and tested.
  • Efficiency – Functional programs consist of independent units that can run in parallel. As a result, such programs are more efficient.
  • Functional programming supports nested functions.
  • Lazy Evaluation – Active programs support lazy active constructions such as lazy lists and lazy maps.
  • On the downside, functional programming requires a large amount of memory space. Since it has no state, you must always create new objects to perform actions.
  • Functional programming is using when several different activities should have to perform on the same set of programs.
  • Lisp is using for artificial intelligence applications such as machine learning, language processing, speech, and vision modeling. Embedded Lisp converters add programming capability to some systems, such as Imax

There are many ideas in the definition of innocent appearance that must need to understand by all before grasping the meaning of active programming:

  • Pure functions
  • Avoid mutating state
  • Avoid shared state
  • Avoid side effects
  • Function composition

In other words, if you want to know what practical programming is in practice, you need to start with an understanding of those basic concepts.

What is a pure function

What is a pure function
What is a pure function

Gives the same input, always gives the same output, and there are No side effects.

Pure functions have many important features of functional programming, including reference transparency (you can replace a function call with its original value without changing the meaning of the program).

What is Function Composition

 Function composition is the process of combining two or more functions to create a new function or perform some calculation. For example, the composition f. g (dot stands for “composite”) is the same as f (g (x)) in JavaScript. Understanding functional composition is an important step in understanding how to build software using functional programming.

What is Commonwealth

Shared status is the property of any variable, object, or memory space that exists within a shared domain. Or it is an object that passes between domains. It is a shared scope that has the ability to include global scope or closure scope. Often, in object-oriented programming, objects are divided between subjects by adding properties to other objects.

For example, a computer game may have the main game object, and letters and game items are stored as a property of that object. Functional programming prevents shared status – instead, it relies on unchangeable data structures. And it clean calculations to extract new data from existing data. See “10 Tips for Better Redux Architecture” for more information on how to handle functional software application status.

The problem with sharing is that in order to understand the functions of a function. Also, you should have to know the entire history of each of the partners’ variables that use or affect the function.

When you abstain from sharing, the time and sequence of function calls do not change the function call mode. With clean functions given the same input, you will always get the same output. This allows active calls to be completely independent of other active calls, which can radically simplify changes and recycling. A change in one function or a crack in a function call does not break the rest of the program.



An immutable object is an object that could not change after it has been created. On the other hand, a mutated object is any object that can change after when it is created.

Immunization is a central concept in functional programming because without it your program’s data flow is lost. State history is the abandoned and strange bugs that have the ability to creep into your software. For more information on the importance of immutability, see “Dawo of Immunization”.

In JavaScript, it is important not to confuse the cons, without modification. Const creates a variable name tag. Those variables cannot reassign after creation. Const does not create objects that cannot change. You cannot change the object to which the binding is directed, but you can still change the properties of the object, which means that the bonds created by the default are deformed and those cannot change.

Those objects could not change those are never can change. You can not really change the value by freezing the object deeply.

In many functional programming languages, there are special unchangeable data structures called tri-data structures (pronounced “tree”) that are effectively frozen. Meaning that no property can change regardless of the property level of the object hierarchy.

Structural sharing uses attempts to share reference memory locations for all parts of an object that remain intact after the operator copied the object. And it is using less memory, and significantly improving performance for certain types of operations.

Side Effects

Side Effects
Side Effects

A side effect is a change in any application conditions that can observe outside of the so-called function other than its benefit value.

Side effects include that are changing any external variable or object property (e.g., a global variable or a variable in the scope of the parent function)

  • Access to the console
  • Writing on the screen
  • Write to a file
  • Writing to the network
  • Triggers any external process
  • Calling any other function with side effects

In action programming, side effects are largely avoided, it is making it easier to understand and test the results of a program.


Thanks for reading the article Functional Programming as an essential component in System design and architecture.

My articles on medium