{"id":694,"date":"2023-02-01T13:08:35","date_gmt":"2023-02-01T13:08:35","guid":{"rendered":"https:\/\/fluxtech.me\/blog\/?p=694"},"modified":"2023-09-05T13:19:19","modified_gmt":"2023-09-05T13:19:19","slug":"object-oriented-programming-vs-functional-programming","status":"publish","type":"post","link":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/","title":{"rendered":"Object-Oriented Programming (OOP) vs Functional Programming (FP)"},"content":{"rendered":"\n

This article takes a deep dive into two fundamental types of programming (Object-Oriented Programming (OOP) & Functional Programming<\/em>) in a side-by-side comparison. The blog was written and contributed by Flux Technologies<\/a>‘ software engineer Samvel Melkonyan<\/em>.<\/p>\n\n\n\n

Defining Object-Oriented Programming (OOP) & Functional Programming<\/h2>\n\n\n\n

Object-Oriented Programming (OOP)<\/strong><\/h4>\n\n\n\n
\n

Object-oriented programming (OOP) is a programming paradigm that is based on the concept of \u201cobjects\u201d, which are instances of a class. These objects contain both data (attributes) and behavior (methods) that describe their characteristics and actions.<\/p>\n<\/blockquote>\n\n\n\n

Functional Programming (FP)<\/strong><\/h4>\n\n\n\n
\n

Functional programming (FP) is a programming paradigm that is based on the concept of \u201cfunctions\u201d that take inputs and produce outputs. These functions are pure, meaning they don\u2019t have side-effects, and are first-class citizens, meaning they can be passed around as arguments or returned as results.<\/p>\n<\/blockquote>\n\n\n\n

Object-Oriented Programming (OOP)<\/h2>\n\n\n\n

Object-Oriented Programming OOP is based on the following four principles<\/a>: Encapsulation<\/code>, Inheritance<\/code>, Polymorphism<\/code>, and Abstraction<\/code>.<\/p>\n\n\n\n

Encapsulation<\/strong><\/h4>\n\n\n\n

Encapsulation allows you to hide the internal state and behavior of an object from the outside world. At the same time it allows the object to be accessed only through a well-defined interface. This means that the internal state of an object is not directly accessible from outside the object, and can only be modified or accessed through the object\u2019s methods. It also allows for the implementation of an object to change without affecting the code that uses the object. This can make the code more robust and maintainable over time.<\/p>\n\n\n\n

class BankAccount {\n  constructor(balance) {\n    this._balance = balance;\n  }\n  \n  deposit(amount) {\n    this._balance += amount;\n  }\n  \n  withdraw(amount) {\n    if (this._balance >= amount) {\n      this._balance -= amount;\n    } else {\n      console.log(\"Insufficient funds\");\n    }\n  }\n  \n  get balance() {\n    return this._balance;\n  }\n}\n\nconst account = new BankAccount(1000);\nconsole.log(account.balance); \/\/ 1000\naccount.deposit(500);\nconsole.log(account.balance); \/\/ 1500\naccount.withdraw(300);\nconsole.log(account.balance); \/\/ 1200<\/code><\/pre>\n\n\n\n
In this example, the BankAccount class has a private variable _balance<\/code> which can only be accessed and modified through the public methods deposit()<\/code> and withdraw()<\/code>. The get<\/code> accessor for the balance<\/code> property allows for reading the value of the private _balance<\/code> variable, but it can’t be set directly from outside the class.<\/p>\n\n\n\n
Inheritance<\/strong><\/h4>\n\n\n\n
Inheritance is a mechanism that allows a new class to be defined based on an existing class, inheriting its attributes and methods. This allows for code reuse and can make development more efficient.<\/p>\n\n\n\n
class Animal {\n  constructor(name, type) {\n    this.name = name;\n    this.type = type;\n  }\n\n  speak() {\n    console.log(`${this.name} makes a sound.`);\n  }\n}\n\nclass Dog extends Animal {\n  constructor(name) {\n    super(name, 'dog');\n  }\n\n  speak() {\n    console.log(`${this.name} barks.`);\n  }\n}\n\nclass Cat extends Animal {\n  constructor(name) {\n    super(name, 'cat');\n  }\n\n  speak() {\n    console.log(`${this.name} meows.`);\n  }\n}\n\nconst dog1 = new Dog('Fido');\ndog1.speak(); \/\/ Fido barks.\nconst cat1 = new Cat('Whiskers');\ncat1.speak(); \/\/ Whiskers meows.<\/code><\/pre>\n\n\n\n
In this example, the Animal<\/code> class is the base class, and Dog<\/code> and Cat<\/code> classes are subclasses that inherit from the Animal<\/code> class. The Dog<\/code> and Cat<\/code> classes have a speak()<\/code> method that overrides the speak()<\/code> method of the base class, so when speak()<\/code> is called on an instance of Dog<\/code> or Cat<\/code>, it will execute the overridden method instead of the base class method.<\/p>\n\n\n\n
Polymorphism<\/strong><\/h4>\n\n\n\n
    \n
  • Lets objects of different classes to be treated as objects of a common base class, and to be used interchangeably. <\/li>\n\n\n\n
  • Allows for more flexibility and can make code more reusable. <\/li>\n\n\n\n
  • Enables the use of a common interface for different classes, making it possible to write code that can work with objects of different types without knowing their specific class.<\/li>\n<\/ul>\n\n\n\n
    class Shape {\n    constructor(name) {\n        this.name = name;\n    }\n    draw() {\n        console.log(`Drawing a ${this.name}`);\n    }\n}\n\nclass Rectangle extends Shape {\n    constructor(width, height) {\n        super('rectangle');\n        this.width = width;\n        this.height = height;\n    }\n    draw() {\n        console.log(`Drawing a ${this.name} with width ${this.width} and height ${this.height}`);\n    }\n}\n\nclass Circle extends Shape {\n    constructor(radius) {\n        super('circle');\n        this.radius = radius;\n    }\n    draw() {\n        console.log(`Drawing a ${this.name} with radius ${this.radius}`);\n    }\n}\n\nlet shape = new Shape('generic shape');\nlet rectangle = new Rectangle(5, 10);\nlet circle = new Circle(3);\n\nlet shapes = [shape, rectangle, circle];\n\nfor (let s of shapes) {\n    s.draw();\n}<\/code><\/pre>\n\n\n\n
    In this example, we have a base class Shape<\/code> and two subclasses Rectangle<\/code> and Circle<\/code> that inherit from it. The draw()<\/code> method is defined in the base class and overridden in the subclasses. The key feature of polymorphism is that the draw()<\/code> method can be called on objects of any of the three classes and it will produce the appropriate output. The shapes<\/code> array contains an instance of each class and the for loop iterates over the array and calls the draw()<\/code> method on each object.<\/p>\n\n\n\n
    Abstraction<\/strong><\/h4>\n\n\n\n
      \n
    • Abstraction is the ability to focus on the essential features of an object, and to ignore non-essential details. <\/li>\n\n\n\n
    • Allows for the creation of classes that are not tied to specific implementations, making the code more flexible and easy to maintain.<\/li>\n\n\n\n
    • Makes it possible to work with objects of a class without knowing the details of their implementation, which can make the code more robust and less error-prone.<\/li>\n<\/ul>\n\n\n\n
      class Vehicle {\n  constructor() {\n    this._engine = null;\n  }\n\n  startEngine() {\n    \/\/ implementation details are hidden\n    \/\/ this._engine.start();\n    console.log(\"Engine started\");\n  }\n\n  stopEngine() {\n    \/\/ implementation details are hidden\n    \/\/ this._engine.stop();\n    console.log(\"Engine stopped\");\n  }\n}\n\nclass Car extends Vehicle {\n  constructor() {\n    super();\n    this._engine = new Engine(\"V8\");\n  }\n}\n\nclass Bike extends Vehicle {\n  constructor() {\n    super();\n    this._engine = new Engine(\"Single Cylinder\");\n  }\n}\n\nclass Engine {\n  constructor(type) {\n    this._type = type;\n  }\n}\n\nconst car = new Car();\ncar.startEngine(); \/\/ \"Engine started\"\ncar.stopEngine(); \/\/ \"Engine stopped\"\n\nconst bike = new Bike();\nbike.startEngine(); \/\/ \"Engine started\"\nbike.stopEngine(); \/\/ \"Engine stopped\"<\/code><\/pre>\n\n\n\n
      In this example, Vehicle<\/code> class provides an abstraction for different types of vehicles, hiding the specific details of each vehicle. The Car<\/code> and Bike<\/code> classes extend the Vehicle<\/code> class and add their own properties and methods, but the user of the class only interacts with the Vehicle<\/code> class and is unaware of the underlying implementation details. This allows for more flexibility and makes the code more modular and easier to maintain.<\/p>\n\n\n\n
      The user of the class only needs to know how to start and stop the engine of the vehicle, and doesn\u2019t have to know the details of the engine type (V8, Single Cylinder). By abstracting away the implementation details, the user can focus on the essential features of the class and ignore non-essential details.<\/p>\n\n\n\n
      Functional Programming (FP)<\/h2>\n\n\n\n
      Here are some of the main principles of functional programming:<\/p>\n\n\n\n
      Pure functions<\/strong><\/h4>\n\n\n\n
      In functional programming, functions are considered the building blocks of the program. and they should be pure, which means they should not have any side effects and should always return the same output given the same input.<\/p>\n\n\n\n
      \/\/ A pure function\nfunction add(a, b) {\n  return a + b;\n}\nconsole.log(add(2, 3)); \/\/ 5\n\n\/\/ An impure function\nlet x = 0;\nfunction addImpure(a) {\n  x += a;\n  return x;\n}\nconsole.log(addImpure(2)); \/\/ 2\nconsole.log(addImpure(3)); \/\/ 5<\/code><\/pre>\n\n\n\n
      Immutability<\/strong><\/h4>\n\n\n\n
      In functional programming, data is immutable, which means that once created, data cannot be modified. This is a key principle of functional programming, as it makes it easier to reason about the program and eliminates the risk of bugs caused by unexpected changes in the state of the program.<\/p>\n\n\n\n
      let x = [1, 2, 3];\n\n\/\/ Modifying x in an impure way\nx.push(4);\nconsole.log(x); \/\/ [1, 2, 3, 4]\n\n\/\/ Modifying x in a pure way\nlet y = [...x, 4];\nconsole.log(y); \/\/ [1, 2, 3, 4]\nconsole.log(x); \/\/ [1, 2, 3]<\/code><\/pre>\n\n\n\n
      Avoid shared state<\/strong><\/h4>\n\n\n\n
      In functional programming, it is generally considered best practice to avoid shared state, which means that functions should not rely on variables or data that is external to the function. Instead, data should be passed as arguments to the function and returned as the result.<\/p>\n\n\n\n
      let counter = 0;\n\n\/\/ A function that uses shared state\nfunction incrementCounter() {\n  counter++;\n  return counter;\n}\nconsole.log(incrementCounter()); \/\/ 1\nconsole.log(incrementCounter()); \/\/ 2\n\n\/\/ A function that avoids shared state\nfunction increment(n) {\n  return n + 1;\n}\nlet count = 0;\nconsole.log(increment(count)); \/\/ 1\ncount = increment(count);\nconsole.log(increment(count)); \/\/ 2<\/code><\/pre>\n\n\n\n
      First-class citizens<\/strong><\/h4>\n\n\n\n
      Here, functions should be treated like any other data type, they can be assigned to variables, passed as arguments to other functions, and returned as values from other functions.<\/p>\n\n\n\n
      \/\/ Assign a function to a variable\nconst add = (x, y) => x + y;\nconst sum = add;\nconsole.log(sum(1, 2)); \/\/ 3\n\n\/\/ Pass a function as an argument to another function\nconst callFunction = (fn, x) => fn(x);\nconsole.log(callFunction(add, 2, 3)); \/\/ 5\n\n\/\/ Return a function from a function\nfunction createCounter() {\n  let count = 0;\n  return function () {\n    return count++;\n  };\n}\nconst counter = createCounter();\nconsole.log(counter()); \/\/ 0\nconsole.log(counter()); \/\/ 1<\/code><\/pre>\n\n\n\n
      Higher-order functions<\/strong><\/h4>\n\n\n\n
      In functional programming, functions can be used as arguments to other functions or returned as the result of a function. This allows for powerful abstractions, such as functional composition and currying.<\/p>\n\n\n\n
      \/\/ A higher-order function\nfunction operateOn(operation, x, y) {\n  return operation(x, y);\n}\n\n\/\/ A function that takes two arguments and returns their sum\nfunction add(x, y) {\n  return x + y;\n}\n\n\/\/ A function that takes two arguments and returns their product\nfunction multiply(x, y) {\n  return x * y;\n}\n\nconsole.log(operateOn(add, 2, 3)); \/\/ 5\nconsole.log(operateOn(multiply, 2, 3)); \/\/ 6<\/code><\/pre>\n\n\n\n
      Recursion<\/strong><\/h4>\n\n\n\n
      In functional programming, recursion is often used as an alternative to loops. Recursive functions are functions that call themselves, and they are well-suited for solving problems that have a recursive structure.<\/p>\n\n\n\n
      \/\/ A recursive function\nfunction factorial(n) {\n  if (n === 0) {\n    return 1;\n  }\n  return n * factorial(n - 1);\n}\nconsole.log(factorial(5)); \/\/ 120<\/code><\/pre>\n\n\n\n
      Lazy evaluation<\/strong><\/h4>\n\n\n\n
      In functional programming, the evaluation of an expression is delayed until its value is needed, this is known as lazy evaluation. This can be useful to improve performance and save memory usage.<\/p>\n\n\n\n
      \/\/ A generator function that returns an infinite sequence of numbers\nfunction* naturalNumbers() {\n  let n = 1;\n  while (true) {\n    yield n++;\n  }\n}\n\nconst numbers = naturalNumbers();\nconsole.log(numbers.next().value); \/\/ 1\nconsole.log(numbers.next().value); \/\/ 2\nconsole.log(numbers.next().value); \/\/ 3<\/code><\/pre>\n\n\n\n
      Scalability of the two paradigms (Object-oriented programming (OOP) and functional programming (FP)<\/h2>\n\n\n\n
      Both Object-oriented programming (OOP) and functional programming (FP) paradigms can be used to write scalable code, but they have different approaches and trade-offs when it comes to scalability.<\/p>\n\n\n\n
      OOP is based on the concept of objects, which can be used to model the problem domain, and it\u2019s often used to create large, complex systems. OOP allows for the creation of reusable code by using inheritance and polymorphism, which can help to reduce the amount of code and increase the scalability of the system. However, OOP can also have some drawbacks when it comes to scalability, such as tightly coupled classes, complex class hierarchies, and the use of global state, which can make the code harder to understand, test and maintain.<\/p>\n\n\n\n
      FP, on the other hand, is based on the concept of functions and data transformations, which can be easily composed, and it\u2019s often used to create small, reusable components. It is based on the principles of immutability and avoiding shared state, which can help to increase the scalability of the system by making the code more predictable and easy to reason about. This also allows for the use of higher-order functions and lazy evaluation, which can help to improve performance and save memory usage. However, FP can also have some drawbacks when it comes to scalability, such as the need for more memory when using immutability, and more complex code when using recursion.<\/p>\n\n\n\n
      Both OOP and FP can be used to create scalable code, but they have different trade-offs. OOP is more suitable for creating large, complex systems, while FP is more suitable for creating small, reusable components. It\u2019s important to choose the right paradigm for the problem at hand and apply best practices and design patterns to increase scalability.<\/p>\n\n\n\n
      Key differences between the two paradigms<\/h2>\n\n\n\n
        \n
      1. OOP focuses on objects, which are instances of a class, and their interactions with each other. FP focuses on functions and their inputs and outputs.<\/li>\n\n\n\n
      2. OOP is based on the principles of encapsulation, inheritance, polymorphism, and abstraction. FP is based on the principles of immutability, referential transparency, higher-order functions, and recursion.<\/li>\n\n\n\n
      3. OOP uses encapsulation to hide the internal state and behavior of an object from the outside world, and to allow the object to be accessed only through a well-defined interface. FP uses immutability to ensure that data cannot be modified after it is created, and referential transparency to ensure that a function will always produce the same outputs given the same inputs.<\/li>\n\n\n\n
      4. OOP uses classes and objects to model real-world entities and their behavior. FP uses functions to describe the transformation of data.<\/li>\n\n\n\n
      5. OOP code often involves a lot of state changes and side-effects, while FP code is typically more predictable and deterministic because it avoids state changes and side-effects.<\/li>\n\n\n\n
      6. OOP code is often more verbose and complex, while FP code can be more concise and elegant.<\/li>\n\n\n\n
      7. OOP is often associated with imperative languages such as Java and C#, while FP is often associated with functional languages such as Haskell, Lisp, and Scheme.<\/li>\n\n\n\n
      8. OOP is often used in object-oriented languages, that means it has a heavier focus on the object\u2019s state, while FP is often used in functional languages, that means it has a heavier focus on the function\u2019s behavior.<\/li>\n<\/ol>\n\n\n\n
        Benefits and drawbacks of each approach<\/h2>\n\n\n\n
        Benefits of OOP<\/strong><\/h4>\n\n\n\n
          \n
        1. OOP allows for the modeling of real-world entities and their behavior, making it easier to understand and reason about complex systems.<\/li>\n\n\n\n
        2. OOP promotes the use of encapsulation, which helps to maintain the integrity of the internal state of an object and to prevent external code from making unintended changes.<\/li>\n\n\n\n
        3. OOP allows for code reuse through inheritance, which can make development more efficient.<\/li>\n\n\n\n
        4. OOP\u2019s encapsulation and inheritance features can make it easier to maintain and extend code over time.<\/li>\n<\/ol>\n\n\n\n
          Drawbacks of OOP<\/strong><\/h4>\n\n\n\n
            \n
          1. OOP can lead to code that is more verbose and complex, which can make it harder to understand and maintain.<\/li>\n\n\n\n
          2. OOP\u2019s emphasis on changing the state of objects can lead to code that is harder to reason about and test.<\/li>\n\n\n\n
          3. OOP\u2019s heavy use of side-effects and state changes can make it harder to reason about the order in which code is executed.<\/li>\n\n\n\n
          4. OOP\u2019s reliance on shared state can make it harder to write concurrent and parallel code.<\/li>\n<\/ol>\n\n\n\n
            Benefits of FP<\/strong><\/h4>\n\n\n\n
              \n
            1. FP promotes the use of immutability, which helps to prevent unintended changes to data and to make code more predictable and deterministic.<\/li>\n\n\n\n
            2. FP\u2019s focus on functions as first-class citizens can make code more modular, reusable, and easier to test.<\/li>\n\n\n\n
            3. FP\u2019s use of recursion and higher-order functions can make it easier to write elegant and expressive code.<\/li>\n\n\n\n
            4. FP\u2019s emphasis on referential transparency can make it easier to reason about the behavior of code.<\/li>\n<\/ol>\n\n\n\n
              Drawbacks of FP<\/strong><\/h4>\n\n\n\n
                \n
              1. FP can lead to code that is more complex and harder to understand, especially for developers who are not familiar with the functional programming concepts.<\/li>\n\n\n\n
              2. FP\u2019s focus on immutability can make it less efficient in certain scenarios, such as when working with large data sets.<\/li>\n\n\n\n
              3. FP\u2019s heavy use of recursion can make it harder to write concurrent and parallel code.<\/li>\n\n\n\n
              4. FP\u2019s use of higher-order functions and closures can make it more difficult to reason about the behavior of code.<\/li>\n<\/ol>\n\n\n\n
                Conclusion<\/h2>\n\n\n\n
                Object-oriented programming (OOP) and functional programming (FP) are two popular programming paradigms that are widely used in industry. Each paradigm has its own strengths and weaknesses and they are suited for different types of problems and use cases.<\/p>\n\n\n\n
                OOP is more suitable for creating large, complex systems, while FP is more suitable for creating small, reusable components.  It\u2019s important to choose the right paradigm and apply best practices and design patterns to increase scalability.<\/p>\n","protected":false},"excerpt":{"rendered":"
                This article takes a deep dive into two fundamental types of programming (Object-Oriented Programming (OOP) & Functional Programming) in a side-by-side comparison. The blog was written and contributed by Flux Technologies‘ software engineer Samvel Melkonyan. Defining Object-Oriented Programming (OOP) & Functional Programming Object-Oriented Programming (OOP) Object-oriented programming (OOP) is a programming paradigm that is based […]<\/p>\n","protected":false},"author":1,"featured_media":705,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"footnotes":""},"categories":[15],"tags":[46,45],"class_list":["post-694","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-web-development","tag-functional-programming","tag-object-oriented-programming"],"acf":[],"yoast_head":"\nObject-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies<\/title>\n<meta name=\"description\" content=\"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Object-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies\" \/>\n<meta property=\"og:description\" content=\"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/\" \/>\n<meta property=\"og:site_name\" content=\"Flux Technologies\" \/>\n<meta property=\"article:published_time\" content=\"2023-02-01T13:08:35+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-05T13:19:19+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fluxtech.me\/blog\/wp-content\/uploads\/2023\/02\/Untitled-design-3.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1920\" \/>\n\t<meta property=\"og:image:height\" content=\"1080\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Flux Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Flux Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"12 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/\",\"url\":\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/\",\"name\":\"Object-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies\",\"isPartOf\":{\"@id\":\"https:\/\/fluxtech.me\/blog\/#website\"},\"datePublished\":\"2023-02-01T13:08:35+00:00\",\"dateModified\":\"2023-09-05T13:19:19+00:00\",\"author\":{\"@id\":\"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/41b838e552fdb243119410f480f6944d\"},\"description\":\"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.\",\"breadcrumb\":{\"@id\":\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/fluxtech.me\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Object-Oriented Programming (OOP) vs Functional Programming (FP)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/fluxtech.me\/blog\/#website\",\"url\":\"https:\/\/fluxtech.me\/blog\/\",\"name\":\"Flux Technologies\",\"description\":\"Blog\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/fluxtech.me\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/41b838e552fdb243119410f480f6944d\",\"name\":\"Flux Team\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/c1c5fc3228772412cf7cb45ed9c2aa6fc008d50d756869eea81624b68d4c4ef6?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/c1c5fc3228772412cf7cb45ed9c2aa6fc008d50d756869eea81624b68d4c4ef6?s=96&d=mm&r=g\",\"caption\":\"Flux Team\"},\"sameAs\":[\"https:\/\/fluxtech.me\/blog\"],\"url\":\"https:\/\/fluxtech.me\/blog\/author\/fluxblogadmin\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Object-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies","description":"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/","og_locale":"en_US","og_type":"article","og_title":"Object-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies","og_description":"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.","og_url":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/","og_site_name":"Flux Technologies","article_published_time":"2023-02-01T13:08:35+00:00","article_modified_time":"2023-09-05T13:19:19+00:00","og_image":[{"width":1920,"height":1080,"url":"https:\/\/fluxtech.me\/blog\/wp-content\/uploads\/2023\/02\/Untitled-design-3.jpg","type":"image\/jpeg"}],"author":"Flux Team","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Flux Team","Est. reading time":"12 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/","url":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/","name":"Object-Oriented Programming (OOP) vs Functional Programming (FP) - Flux Technologies","isPartOf":{"@id":"https:\/\/fluxtech.me\/blog\/#website"},"datePublished":"2023-02-01T13:08:35+00:00","dateModified":"2023-09-05T13:19:19+00:00","author":{"@id":"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/41b838e552fdb243119410f480f6944d"},"description":"This article takes a deep dive into two fundamental types of programming in a side-by-side comparison.","breadcrumb":{"@id":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/fluxtech.me\/blog\/object-oriented-programming-vs-functional-programming\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fluxtech.me\/blog\/"},{"@type":"ListItem","position":2,"name":"Object-Oriented Programming (OOP) vs Functional Programming (FP)"}]},{"@type":"WebSite","@id":"https:\/\/fluxtech.me\/blog\/#website","url":"https:\/\/fluxtech.me\/blog\/","name":"Flux Technologies","description":"Blog","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fluxtech.me\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/41b838e552fdb243119410f480f6944d","name":"Flux Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fluxtech.me\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/c1c5fc3228772412cf7cb45ed9c2aa6fc008d50d756869eea81624b68d4c4ef6?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c1c5fc3228772412cf7cb45ed9c2aa6fc008d50d756869eea81624b68d4c4ef6?s=96&d=mm&r=g","caption":"Flux Team"},"sameAs":["https:\/\/fluxtech.me\/blog"],"url":"https:\/\/fluxtech.me\/blog\/author\/fluxblogadmin\/"}]}},"_links":{"self":[{"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/posts\/694","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/comments?post=694"}],"version-history":[{"count":9,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/posts\/694\/revisions"}],"predecessor-version":[{"id":767,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/posts\/694\/revisions\/767"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/media\/705"}],"wp:attachment":[{"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/media?parent=694"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/categories?post=694"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fluxtech.me\/blog\/wp-json\/wp\/v2\/tags?post=694"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}