1. Disclaimer:
The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

2. What is a XXX Language?
XXX = dynamic
XXX = imperative
XXX = OO

3. A language where functions are first-class citizens
What is a Functional Language
A language where functions are first-class citizens

4. EWD 1073

6. Easy like
Sunday morning

7. Dan
Meyer
WTF
went
wrong?

8. Doing IO is a side-effect
Console.WriteLine(“ha”); !=
var x = Console.ReadLine(); var y = x+x; !=
var y = Console.ReadLine() Console.ReadLine()

9. DateTime.Now is not a mathematical function
Doing IO is a side-effect
let date = DateTime.Now() in (date, date) 
( DateTime.Now() , DateTime.Now() )
DateTime.Now is not a mathematical function

10. Functional Programming is just academic nonsense
If I cannot even do IO
Fundamentalist
Functional Programming
is just academic nonsense

11. Don’t
eat
The
Yellow
Snow!

12. C# Lazy evaluation and side-effects
static bool LessThanThirty(int x) { Console.Write("{0}? Less than 30;",x); return x < 30; }
static bool MoretHanTwenty(int x) { Console.Write("{0}? More than 20;",x); return x > 20; }
var q0 = from x in new[]{ 1, 25, 40, 5, 23 } where LessThanThirty(x) select x;
var q1 = from x in q where MoreThanTwenty(x) select x;
foreach (var r in q1) Console.WriteLine("[{0}];",r);
Order of side effects?

14. F# Lazy comprehensions
let lessThanThirty(x:int)= begin
Console.WriteLine ("{0} less than 30?", x);
x < 30;
end
let moreThanTwenty(x:int)= begin
Console.WriteLine ("{0} more than 20?", x);
x > 20;
let q0 = seq { for x in [1; 25; 40; 5; 23] do
if lessThanThirty x
then yield x }
let q1 = seq { for x in q0 do
if moreThanTwenty x
for r in q1 do Console.WriteLine("> {0},", r) F#
Lazy comprehensions

15. F# Eager comprehensions
let lessThanThirty(x:int)= begin
Console.WriteLine ("{0} less than 30?", x);
x < 30;
end
let moreThanTwenty(x:int)= begin
Console.WriteLine ("{0} more than 20?", x);
x > 20;
let q0 = [ for x in [1; 25; 40; 5; 23] do
if lessThanThirty x
then yield x ]
let q1 = [ for x in q0 do
if moreThanTwenty x
for r in q1 do Console.WriteLine("> {0},", r) F#
Eager comprehensions

16. Exceptions var xs = new[]{ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
IEnumerable<int> q = null;
try { q = from x in xs select 1/x; } catch {
q = new int[]; }
foreach(var z in q)
Console.WriteLine(z): // throws here

18. Disposing resources Func<string> GetContents = null;
using( var file = { GetContents =
() => file.ReadToEnd(); }
// surprise! an exception Console.WriteLine(GetContents());

19. Variable Instantiation
var DelayedActions = new List<Func<int>>();
var s = "";
for (var i = 4; i < 7; i++) {
DelayedActions.Add(delegate(){ return i; }); }
for (var k = 0; k < DelayedActions.Count; k++)
s += DelayedActions[k]();
Console.WriteLine(s);
Prints 777

20. Variable Instantiation
var DelayedActions = new List<Func<int>>();
var s = "";
for (var i = 4; i < 7; i++) {
var j = i;
DelayedActions.Add(delegate(){ return j; }); }
for (var k = 0; k < DelayedActions.Count; k++)
s += DelayedActions[k]();
Console.WriteLine(s);
Prints 456 C#
Prints 666
JavaScript

21. Variable Instantiation
var DelayedActions = new List<Func<int>>();
var s = "";
var j; for (var i = 4; i < 7; i++) {
j = i;
DelayedActions.Add(delegate(){ return j; }); }
for (var k = 0; k < DelayedActions.Count; k++)
s += DelayedActions[k]();
Console.WriteLine(s);
Prints 666

22. Object creation
var o1 = new object(); // , for instance Console.WriteLine(o1.GetHashCode()); var o2 = new object(); // , for instance Console.WriteLine(o2.GetHashCode()); Debug.Assert(o1 != 02);

23. Concurrency new_cell(X) -> spawn(fun() -> cell(X) end).
cell(Value) ->
receive
{set, NewValue} -> cell(NewValue);
{get, Pid} > Pid!{return, Value}, cell(Value);
{dispose} > {}
end.
set_cell(Cell, NewValue)
-> Cell!{set, NewValue}.
get_cell(Cell) ->
Cell!{get, self()},
{return, Value} -> Value
dispose_cell(Cell) -> Cell!{dispose}.

24. Page 165: There is a subtle error in on_exit and keep_alive … Write your code such that race conditions cannot happen. …
Fortunately, the OTP libraries have code for building servers, supervisor trees, and so on.
These libraries have been well tested and should not suffer from any race conditions.

26. few interesting functions are idempotent
*not* idempotent
*not* pure
few interesting
functions are
idempotent
GET …/person/age… GET …/clock/seconds…

27. “Dishonest” types static T Identity<T>(this T me) {
Not
parametric!
static T Identity<T>(this T me) {
if(me.GetType() == typeof(Button))
throw new Exception();
var mini_me = me as string;
if(mini_me != null) return “hello world”;
Console.WriteLine(me.ToString());
return Activator.CreateInstance<T>(); }

28. HOT Languages
To the rescue

29. Haskell lessThanThirty x = do { putStrLn $ (show x)++" less than 30?"
; return $ x < 30 }
moreThanTwenty x = do { putStrLn $ (show x)++" more than 20?"
; return $ x > 20
q0 = [ x | x <- [1, 25, 50, 5, 23 ] , lessThanThirty x ]
q1 = [ x | x <- q , moreThanTwenty ]
Couldn't match expected type `Bool' against inferred type `IO Bool'
In a stmt of a list comprehension: lessThanThirty x
In the expression: [x | x <- [1, 25, 50, ....], lessThanThirty x]
In the definition of `q0':
q0 = [x | x <- [1, 25, ....], lessThanThirty x
Haskell

30. Forget about effects? Forget it!
unsafePerformIO :: IO a -> a
unsafeCast :: a -> b unsafeCast x = unsafePerformIO $
do{ writeIORef castref x
; readIORef castref }
castref = unsafePerformIO $
do{ newIORef undefined }

31. Cover up effects

32. Remove all effects (cannot make language more powerful
by removing features)

33. Don’t fight effects Embrace and extend

34. Mens sana in corpore sano

35. Mistake
DateTime.Now() DateTime
Type error !!!!!!!!!!!!!!!

36. Time changes, the clock does not
Values vs Computation
How to turn something mutable into something immutable?
Time changes, the clock does not

37. It’s just a collection … 9:15 AM 9:16 AM 9:17 AM 9:19 AM 9:29 AM
All problems in computer science can be solved by another level of indirection
D. Wheeler

38. Mathematics
is always right

39. But many ways to be impure
Only one way to be pure,
But many ways to be impure
Multithreading
 STM<T>
Exceptions
 Throws<T>
Reflection
 Mirror<T>
Destructive updates
 IO<T>

40. The “M” word
M  IO Exception Animation Collection
Monads
M<A> A computation that produces a value of type A with side-effects described by M

41. Side-effecting computation that yields a value of type a
data IO a
putChar :: Char -> IO ()
getChar :: IO Char
newIORef :: a -> IO (IORef a)
readIORef :: IORef a -> IO a
writeIORef :: IORef a -> a -> IO () forkIO :: IO a -> IO ThreadID

42. Fundamentalist Functional
Can
Normal
Programmers
Understand
Fundamentalist Functional
Programming?

44. LINQ Monads are the secret sauce behind LINQ Bind
IEnumerable<S> SelectMany<T,S>( IEnumerable<T> src, Func<T, IEnumerable<S>> selector )

45. Java Throws clause void Foo(string s) throws Exception Explicit
Effects

46. Abstract from evaluation order Make all effects explicit ==>
Fundamentalist
Functional
Programming
Abstract from evaluation order
Make all effects explicit
==>
Compiler can freely rearrange code
Runtime can execute in code any order
Call-by-name, or call-by-value
version?

47. Call To Action Buy Graham Hutton’s book
Nudge and nag MS to produce a fundamentalist functional language

48. Buy Bryan John & Don’s book
Nudge and nag
MS to produce a
fundamentalist
functional language

49. Thank
You