Thread by @orbisproject

A mission-critical financial application must be safe & secure.

When the #Crypto industry goes through multi-million dollar hacks,

building a robust financial platform has been the core driving principle of #Cardano

So here's a thread on Functional Programming: 🧵👇

The public blockchain sphere has been growing rapidly over the past decade

If we reflect on that growth,

it has mainly been on the valuation side of things

and not that much on the utility or user side of things

So why is it that way?

One of the reasons for this lack of growth in utility is the lagging scalability

But there is another elephant in the room, which most don't address

This is the lack of a secure programming environment for the #dApps

and the rest of the #blockchain infrastructure

This lack of security is the most important reason why

#DeFi attracts high-risk tolerant speculative investors

who can tolerate the loss of funds due to hacks

rather than regular risk-averse users

who may want to build a decent portfolio of assets & earn a stable yield

So when it comes to enabling a safe & secure programming environment
#Cardano has a unique approach

In contrast to the rest of the #blockchain industry (especially #Ethereum)

This is the approach based on secure programming with functional
programming language #Haskell

So what is functional programming?

Functional programming is the process of building software by composing pure functions

which avoids

• shared state
• mutable data
• side-effects

So what are pure functions?

In the context of computation,

a pure function is analogous to a mathematical function

which is the basis for all formal scientific reasoning It is a function (a block of code)

that always returns the same result

If the same arguments are passed

A function must follow four rules to behave like a function in math:

• It must always take an argument

• It must always return a value

• It must not depend on anything that changes

• It must not change anything by itself A function with such properties is called "Pure"

Pure functions are "stateless" and "timeless"

Meaning,

Pure functions are easily parallelizable since they encourage immutable data structures

which reduces the side-effects

making code hard to run on multiple processors

Pure functions are just mappings from inputs to outputs 

It does not depend on any state or data change during a program’s execution

There are no external states & side effects

This gives certainty & predictability to the behaviour of the code

Haskell has 1st-class functions

A programming language is said to have 1st-class functions

When functions are no different from any other variable

So the functions

• Can be used as arguments
• Can be assigned to a variable
• Can be returned as values from other functions

1st class functions allow to abstract out

Any repetitive computation from the code

And ultimately enables to write functions that produce other functions

These functions are referred to as higher-order functions

Higher-order functions simply mean

Functions that are operating on other functions

Why is it useful?

1. Higher-order functions raise the level of abstraction

Meaning

It allows to abstract over actions & not just values

Thus, we don’t have to reason about lower-level details

2. Higher-order functions are key to parameterizing code by behaviour

Meaning,

It allows us to define common programming patterns

And write functions about functions

Having higher-order functions is where a lot of the benefits of functional programming come from

In a nutshell

• Functional programming uses mathematics-like values & functions

• To yield results that have no outside influence & are well-evaluated throughout

• Leading to a more parallelizable transparent & cleaner code

• That helps the user in debugging & maintenance

On the other hand, programming in a dynamic environment with object-oriented programming

Results in the creation of huge "Dependency Hell"

Resulting in adding abstraction on top of abstraction to modularize complex systems

This results in a "shared mutable state/global state"

When submodules try to access the global state simultaneously

This significantly complicates the semantics of the code

Complexity arises & it results in a chaotic programming environment

In other words, it creates a much bigger surface area for attacks

So now let's take a look at the functional programming model of #Cardano

Plutus platform uses

• Haskell for the off-chain
• PlutusTX for the on-chain code

Which compiles down to Plutus Core

enabling the use of the same

• Syntax
• Compiler
• Data types in both parts of the code

This translates to an integrated, compact & robust programming model

Meaning,

Its a lot easier to reason about the behaviour of a smart contract

while programming a smart contract in Plutus

It won't be too difficult to actually prove that

code will behave exactly how it is supposed to

enabling easily verifiable code for secure & safe dApps

If the #blockchain industry could open its eyes & see the benefits of functional programming

A pure functional programming language like #Haskel

would be the go-to programming language for #dApps

that would one day handle a major portion of the world's financial activities 

when it comes to the programming environment of zk-rollup

Orbis will support writing on-rollup smart contract scripts in Haskell using

• PlutusTx
• Plutarch
• and in Pluto

There are a variety of reasons that make Plutus Tx currently inefficient

Pluto & Plutarch are novel programming languages based on Haskell

Plutarch is significantly more efficient than Plutus Tx

Whereas Pluto is simple & easy to learn

These two languages hold a lot of promise for the future of a secure programming environment on #Cardano

Especially Pluto that one day will be #Cardano's Solidity

Along with the benefits of functional programming

TL;DR -

• Mission-critical DeFi application needs to be safe & secure for mass adoption

• Object-oriented programming fails to deliver this secure programming environment

• #Cardano offers a secure programming environment with #Haskell-based PlutusTx, Plutarch & Pluto

If you are looking to learn more about zero-knowledge proofs and zk-rollups —

Here’s a similar thread on Rollups on #Cardano that you might find useful:

https://twitter.com/orbisproject/status/1554843370723352578?s=20&t=GXvjed57QOu3ssBDHkxYBA