Presented at Open Source South Carolina, 8/14/19 Presented by Drew Varner, Owner of NineFX Abstract: The talk will survey the functional programming landscape. We will introduce different functional languages and discuss their strengths and weaknesses. We will look at major open source projects powered by functional languages and discuss who is using them and why.

1. Intro to Functional
Programming

2. Roadmap
• About us
• Why functional?
• Taxonomies
• Who uses it?
• Popular projects
• Examples

3. Who am I?
Drew Varner, Developer
• Erlang, Elixir, ReasonML, Scala
• Member: Erlang Ecosystem Foundation (EEF)
• Member: EEF Security Working Group
• Voting Member: OASIS Open CTI, OpenC2, and MQTT
Technical Committees
• Co-editor: TAXII 2.1 Specification

4. Who are we?
NineFX, Inc.
• Software company @ USC/Columbia Technology Incubator
• Actively supporting and developing functional software for
Federal clients
• Software written in Erlang, Elixir, and ReasonML

5. The right tools
Why?
• Immutability (Concurrency)
• Hindley–Milner (HM) type systems
• ML languages
• Haskell
• Recursion
• Especially tail recursion
• Little to no side effects
• Referential transparency

6. This stuff isn't new
Lisp 1958
ML 1972
Caml 1987
Erlang 1987
Haskell 1990
https://xkcd.com/297/

7. For fun
Why?
• A different way to think about
programming
• Off the beaten path
• Fun, close-knit communities
• Remote work opportunities

8. A Rough Taxonomy
HaskellML (Meta
Language)
StandardML F# OCaml
ReasonML
Elm Lisp
Common
Lisp
Scheme
Clojure &
ClojureScript
Erlang
Elixir

9. Haskell
https://xkcd.com/1312/

10. Another Taxonomy (Runtimes)
Native
Haskell
OCaml
Common Lisp
Scheme
Idris
Java
Clojure
Scala
.Net
F#
IronScheme
JavaScript
ReasonML
OCaml
ClojureScript
Haskell
Idris

11. Who uses functional languages?
Scala Twitter, LinkedIn, Netflix, Airbnb, NineFX
Clojure Boeing, Walmart, CircleCI
Erlang WhatsApp (Facebook), Cisco, NineFX
Elixir Brex, Bleacher Report, NineFX
OCaml Jane Street, Bloomberg
Haskell Galois
ReasonML Facebook, NineFX
Elm No Red Ink

13. Anything OO can do, we can do…
• Web application frameworks
• Elixir: Phoenix
• Scala: Play Framework
• Clojure: Luminus
• Computation-intensive tasks
• Front-end, especially JavaScript
• Elm
• ClojureScript
• Scala-js
• Haskell (ghcjs, miso)
• OCaml (js_of_ocaml, Bucklescript, ReasonML )

14. Well Known Functional Projects
Apache CouchDB Erlang NoSQL Database
Ejabberd/MongooseIM Erlang Chat servers
Phoenix Elixir Web framework
Apache Kafka Scala Streaming Platform
Apache Spark Scala Analytics Engine
Facebook Flow OCaml Static Typing for JavaScript
pandoc Haskell Universal Markup Converter
Radamsa Scheme Fuzzer
Next browser Lisp Web Browser

15. Coding Examples
io:format("Hello World~n!").

16. Tools of the trade: asdf
clojure coq chicken (Scheme)
elixir elm erlang
haskell scala ocaml
racket
(Scheme derivative)
lfe
(Lisp-flavored Erlang)

17. Immutability (Object-Oriented)
List<Integer> items = new ArrayList<Integer>();
items.add(1);
items.add(2);
trustme.borrow(items);
// ...
int total = 0;
for (int i=0; i < items.size(); i++) {
total = total + items.get(i);
}

18. Immutability (Functional)
sum(List) -> sum(List, 0).
sum([], Acc) -> Acc;
sum([Head | Rest], Acc) ->
sum(Rest, Acc + Head).
lists:foldl(fun(X, Sum) -> X + Sum end, 0, List).

19. Immutability, a big change
Erlang Elixir Scala
1> A = 1.
1
2> A = A + 1.
** exception
error: no match of
right hand side
value 2
iex(1)> a = 1
1
iex(2)> a = a + 1
2
scala> var x = 1
x: Int = 1
scala> x = x + 1
mutated x
scala> val y = 1
y: Int = 1
scala> y = y + 1
^
error: reassignment to val

20. Side Effects
Object-oriented
public class MyClass {
private int cntr = 0;
public void incr() {
cntr += 1;
}
}
Functional
incr(Val) -> Val + 1.

21. Lists in Erlang
• Singly linked lists
• Head of list: first item
• Tail of list: remaining items
A B C
Eshell V10.3.1 (abort with ^G)
1> List = ["A", "B", "C"].
["A","B","C"]
2> hd(List).
"A"
3> tl(List).
["B","C"]

22. Pattern Matching
The pipe operator: [ Head | Tail ]
The anonymous variable _
1> Notes = ["Doe", "Ray", "Me", "Far", "Sew"].
["Doe","Ray","Me","Far","Sew"]
2> [First | _ ] = Notes.
["Doe","Ray","Me","Far","Sew"]
3> First.
"Doe"
4> [_, Second | _ ] = Notes.
["Doe","Ray","Me","Far","Sew"]
5> Second.
"Ray"

23. Reversing Lists by Recursion
-module(reverse).
-export([reverse/1]).
reverse(List) ->
reverse(List, []).
reverse([], Acc) ->
Acc;
reverse([Head | Rest], Acc) ->
reverse(Rest, [Head | Acc]).
List Head Rest Acc
[1,2,3] 1 [2, 3] []
[2,3] 2 [3] [1]
[3] 3 [] [2,1]
[] [3,2,1]
reverse:reverse([1 ,2, 3]).

24. https://xkcd.com/1270/

25. Factorial
𝟎! = 𝟏
𝒏! = 𝒏 ⋅ 𝒏 − 𝟏 !
From https://learnyousomeerlang.com/recursion
𝟓! = 𝟓 ⋅ 𝟒!
𝟒! = 𝟒 ⋅ 𝟑!
𝟑! = 𝟑 ⋅ 𝟐!
𝟐! = 𝟐 ⋅ 𝟏!
𝟏! = 𝟏 ⋅ 𝟎!
𝟎! = 𝟏
𝟓 ⋅ 𝟒 ⋅ 𝟑 ⋅ 𝟐 ⋅ 𝟏

26. Recursive Factorial (Erlang)
-module(fac).
-export([fac/1]).
fac(N) when N == 0 -> 1;
fac(N) when N == 1 -> 1;
fac(N) when N > 0 -> N*fac(N-1).
From https://learnyousomeerlang.com/recursion
1> fac:fac(5). % 5 * 4 * 3 * 2 * 1
120

27. Recursive Factorial (OCaml)
let rec fact n accum =
if n <= 1 then
accum
else
fact (n-1) (accum*n);;
let factorial n =
fact n 1;;

28. Type Inference (ReasonML)
type traffic_light_color = Green | Yellow | Red;
let react = (color) =>
switch(color) {
| Green => "go"
| Yellow => "go fast"
| Red => "stop"
};
let react: traffic_light_color => string = <fun>

29. Type Inference (ReasonML)
type traffic_light_color = Green | Yellow | Red;
let react = (color) =>
switch(color) {
| Green => "go"
| Yellow => "go fast"
};
let react: traffic_light_color => string = <fun>

30. Thanks!
drew.varner@ninefx.com
https://www.ninefx.com
@ varnerac
varnerac/NineFX