Expression Oriented Programming with F#

This talk take a deep look at some of the basics of programming: expressions, statements, scope and how we represent data. We’ll look at these concepts to through the lens of a functional programmer to see how this, contrasts to the way an Object Oriented programmer might do things. We’ll look at how these ideas effect application architecture both “in the large” and “in the small”. “In the large” meaning overall system design and “in the small” meaning design of individual classes, methods and functions.Once we’ve examined the basics, we’ll go on to take a look at one of the biggest problems faced by software developers: complexity. We’ll see how complexity can either be accidental or essential. We’ll see how expression oriented programming can help us avoid accidental complexity and help us crawl out of the tar pit.The examples will see will use F#, but the ideas will be applicable to any language that encourages the use of expressions rather than statements.

Transcript

1. Robert Pickering
2. Programming is about data You have been fooled into thinking it’s about APIs
3. Functional Programming is not about programming without state
4. It is about succinctly describe the transformation between one state another, in a way that is composable.
5. Purity: only relying on data that’s passed as a parameter
6. The devil is in the detail Programming in the large Programming in the small versus
7. The Software Crisis Complexity Conformity Changeability Invisibility
8. Essential Complexity Accidental Complexity versus
9. Have you tried turning it off and on again?
10. Command-line App File File Service/Daemon Network I/O Network I/O GUI App User Input Image Data The only three apps you’ll ever write …
11. Long running app statement oriented style Process Event Environment
12. Long running app expression oriented style Process Event Environment
13. Expressions vs Statements An expression is something that evaluates to value A statement is everything else
14. If in a statement oriented language string firstArg = null; if (args.Length > 0) { firstArg = args[0]; }
15. If in a expression oriented language let firstArg = if argv.Length > 1 then argv.[0] else ""
16. What about the ternary operator? string firstArg = (args.Length > 0) ? args[0] : "";
17. There are limits to the ternary operator let firstArg = if argv.Length > 1 then let argString = argv.[0] argString.Trim() else ""
18. If statement with two values string firstArg = null; string secondArg = null; if (args.Length > 1) { firstArg = args[0]; secondArg = args[1]; }
19. If expression with two values let firstArg, secondArg = if argv.Length > 1 then argv.[0], argv.[1] else "", ""
20. Data gets trapped inside statements and needs to be pushed to a specific location in the outside world
21. Lock statement static object sync = new object(); static string[] items = new string[] { "1", "2", "3" }; static void DoItemEx5(int index) { string myDataPoint = null; lock (sync) { myDataPoint = items[index]; } // ... }
22. Lock expression/function let sync = new obj() let items = [| "1"; "2"; "3"|] let DoItemEx5 index = let myDataPoint = lock sync (fun () -> items.[index]) // ...
23. Using statement string myDataPoint = null; using (var conn = new SqlConnection()) { conn.Open(); using (var cmd = conn.CreateCommand()) { cmd.CommandText = "select field from table"; myDataPoint = (string)cmd.ExecuteScalar(); } }
24. use binding use conn = new SqlConnection() conn.Open(); use cmd = conn.CreateCommand(CommandText = "select field from table") let myDataPoint = cmd.ExecuteScalar() :?> string
25. Statement oriented programming emphasizes reading and write, and so creates coupling with the points being read from/written to
26. Expression oriented programming emphasizes the calculations and transformation between one value and another.
27. The process of refactoring towards purity generally involves disentangling computation from the environment it operates in, which almost invariably means more parameter passing John Carmack Functional Programming in C++
28. Ways to get data into a function 1. Read the data from somewhere 2. Have the caller pass the data to you as a parameter
29. The inconvenience of parameters let bigFunc thing1 otherThing thirdItem moreStuff gettingBordNow engoughAlready = // ...
30. Nesting functions reduce need for parameters let bigFunc' thing1 otherThing thirdItem moreStuff gettingBordNow engoughAlready = let doSomething1 index = (thing1 + index) - thirdItem let doSomething2 index = (thing1 + otherThing) * moreStuff doSomething1 1 |> doSomething2 // ...
31. class BadClass { int thing1; int otherThing; int thirdItem; int moreStuff; int gettingBordNow; int engoughAlready; int DoSomething1(int index) { return (thing1 + index) - thirdItem; } int DoSomething2(int index) { return (thing1 + otherThing) * moreStuff; } public int BigFunc(int thing1, int otherThing, int thirdItem, int moreStuff, int gettingBordNow, int engoughAlready) { // ... unpack fields ... return DoSomething2(DoSomething1(1)); } }
32. Nested functions offer better protection than private fields let hardWorkingFunc environment = let buffer = Array.zeroCreate 255: int[] let doWork1 parameter = // do some more work with buffer () let doWork2 parameter = for x in buffer do doWork1 x buffer
33. class HardWorkingClass { int[] buffer = new int[255]; private void DoWork1(int parameter) { // do some more work with buffer } private void DoWork2(int parameter) { foreach (var x in buffer) { DoWork1(x); } } public int[] HardWorkingFunction() { DoWork2(1); return buffer; } } // game over!
34. The problem with fields
35. public class Stuff { } public interface IRepository { Stuff[] GetStuff(); } public class MockableClass { IRepository _repository; public MockableClass(IRepository repository) { _repository = repository; } // ... } A word on mocking …
36. Testability: Take a dependencies on anything other than the data pasted to you, and the test will need to ensure those dependencies are correctly initialized
37. .NET Type System The .NET type system guarantees that a reference either points to valid instance or null
38. NullReferenceException
39. F# Type System The F# type system guarantees that a reference either points to valid instance or null (or at least tries very hard to)
40. Tuples let tuple = "first", 2 let first, two = tuple
41. Record Types type Person = { FirstName: string; LastName: string; }
42. Record Types let person = { FirstName = "Robert"; LastName = "Pickering"; } let person' = { person with LastName = "Townson"; }
43. Union Types type Choice<'a, 'b> = | Choice1 of 'a | Choice2 of 'b
44. Union Types let aChoice = Choice1 "made" let whichChoice = match aChoice with | Choice1 value -> sprintf "Choice1 %A" value | Choice2 value -> sprintf "Choice2 %A" value
45. 45 // pipe forward let (|>) x f = f x Pipe Forward
46. 46 Pipe Forward let items = [ 1 .. 10 ] let squares = Seq.map (fun x -> x * x) (Seq.filter (fun x -> x > 3) items) let squares' = items |> Seq.filter (fun x -> x > 3) |> Seq.map (fun x -> x * x)
47. 47 // compose let (>>) f g x = g (f x) Compose let compose func1 func2 value = let result = func1 value func2 result
48. 48 let length (s: string) = s.Length let makeString i = new String('a', i) let combinedFunction = length >> makeString combinedFunction "1234" // result "aaaa" Compose
49. An LOB app using composition
50. type Request = { name:string; email:string } A type to hold the data
51. A type to represent success or failure // the two-track type type Result<'TSuccess,'TFailure> = | Success of 'TSuccess | Failure of 'TFailure
52. let validate1 input = if input.name = "" then Failure "Name must not be blank" else Success input let validate2 input = if input.name.Length > 50 then Failure "Name must not be longer than 50 chars" else Success input let validate3 input = if input.email = "" then Failure "Email must not be blank" else Success input Validation functions
53. bind let bind inputFunction inputValue = match inputValue with | Success s -> inputFunction s | Failure f -> Failure f
54. bind let combindedValidate = let validate1' = bind validate1 let validate2' = bind validate2 let validate3' = bind validate3 validate1' >> validate2' >> validate3' let altCombindedValidate = bind validate1 >> bind validate2 >> bind validate3
55. plus let plus addSuccess addFailure switch1 switch2 x = match (switch1 x),(switch2 x) with | Failure f1,Success _ -> Failure f1 | Success _ ,Failure f2 -> Failure f2 | Success s1,Success s2 -> Success (addSuccess s1 s2) | Failure f1,Failure f2 -> Failure (addFailure f1 f2)
56. plus let combineFailures v1 v2 = let addSuccess r1 r2 = r1 // return first let addFailure s1 s2 = s1 + "; " + s2 // concat plus addSuccess addFailure v1 v2
57. plus let combinedValidation = validate1 |> combineFailures validate2 |> combineFailures validate3
58. Normalizing the data let canonicalizeEmail input = { input with email = input.email.Trim().ToLower() }
59. map let map f inputValue = match inputValue with | Success s -> Success (f s) | Failure f -> Failure f
60. map let usecase = combinedValidation >> map canonicalizeEmail
61. let updateDatabase input = () // dummy dead-end function for now Updating the database
62. tee let tee f x = f x; x
63. let tryCatch f exnHandler x = try Success(f x) with | ex -> Failure(exnHandler ex) tryCatch
64. let updateDatebaseStep request = tryCatch (tee updateDatabase) (fun ex -> ex.Message) request Converted db function
65. Completed Usecase let usecase = combinedValidation >> map canonicalizeEmail >> bind updateDatebaseStep
66. let mainCompile (argv,bannerAlreadyPrinted,exiter:Exiter,createErrorLogger) = // Don's note: "GC of intermediate data is really, really important here" main1 (argv,bannerAlreadyPrinted,exiter,createErrorLogger) |> main2 |> main2b |> main2c |> main3 |> main4 In the real world …
67. With a big thanks to … Railway oriented programming http://fsharpforfunandprofit.com/posts/recipe-part2/
68. Further Reading
70. Questions?