As the Internet of Things reaches maturation and begins to become commonplace in our lives, the technology used to support IOT must be chosen well. With potentially millions of devices connected, developing applications to support these devices and the data they produce, while converting that data into something meaningful, will require thoughtful attention to technology choices. In building any system, attention to architecture and technology stacks is important, but if IOT delivers on its promise of scale, the technology implications will be very different than what we've had to solution and develop for before. It will not be enough to simply "use what we've always used" and to keep building things the way we've been building them. The challenges are far too complex to not take a step back and look at other options.
What challenges does IOT present?
Scalability and concurrency are likely the two biggest challenges that IOT will bring about. Think of the scale of data that these devices will produce and the number of applications that will be developed to handle those devices and their data; there is the potential for great complexity in designing these systems. While scaling problems can sometimes be solved by adding more infrastructure, this solution won't apply to the potentially massive amount of Internet-connected devices. And concurrency is an even bigger problem. Millions of devices and real-time communication amongst these devices and consumer-end applications means millions of concurrent connections. Thread-locking and race conditions get hairy fast. Great strides have been made in recent years with non-blocking technology such as Node.js, but this of course won't be nor should it be the only solution used.
As systems become more complex, so does the underlying codebase, and so we can consider code readability to be just as important as the other two factors.
Functional Programming as the paradigm
Functional programming is well-suited to help solve these challenges. The properties of functional programming - preference for immutability, function composition, avoiding side-effects, less code, etc. - will help avoid many of the pitfalls of an IOT world. Immutable data helps solve the concurrency issue as locks can be avoided. Real-time communication is also better supported by FP. As an aside here, it should be noted that not all FP languages are strictly immutable (for example Haskell has mutable data structures). Furthermore, not all FP languages are created equal when it comes to concurrency management - some perform better than others. This is important to keep in mind when selecting the right language for your application use-case.
Another benefit is side-effect free functions. While some FP languages are more liberal than others in their allowance of side-effects, FP as a whole favors side-effect free. This is of great use when programming IOT applications as it makes scaling easier while making the code easier to reason about. Functions without side-effects can be run in parallel much easier than functions with side-effects as functions that only take inputs and produce outputs only care about their individual inputs and outputs, not other operations like database calls. This same reason is why side-effect free functions also have the benefit of being able to be better optimized.
Lastly, with FP there is just less code to write, which means less bugs, which means better programs.
What IOT-like applications are currently using FP languages?
- League of Legends chat
- Facebook chat (first version, now using C++)
- Numerous game servers (Call of Duty, Battlestar online)
- Numerous trading/financial companies
As you can see, many of these applications above have similar challenges as those posed by IOT, namely many concurrent connections (chat, WhatsApp, games servers) and scale (all of the above). FP has proven itself in the above applications, furthering the argument that it is a prime candidate for IOT.
There's still room for OOP
There's still room at the table for Object-Oriented programming, although it probably shouldn't be the dominant paradigm. It's called Internet of Things for a reason, and OOP can still be useful in describing and reasoning about those things. However, central to IOT is data and communication, and it's easier to reason about this with FP than OOP.
A better glue
Out of the box, Internet-connected devices will rely on the applications and systems that support them to maintain this connectedness and communication, and so these supporting systems must have a good way of doing so. As John Hughes worded it in his "Why Functional Programming Matters" paper, "... a language must provide good glue." Functional programming is that "good glue" that will help enable technologists to solve many of the challenges brought about by IOT.