Learning Functional Programming in Go by Sheehan, Lex -- Read -- Imperial Library of Trantor

This OOP method stinks Our FP function smells like roses In FP, contracts don't lie Duck typing What can go wrong with inheritance? Interface segregation principle Dependency inversion principle

The big reveal

MapReduce

MapReduce example

What else can Monads do?

Viva La Duck

Pass by value or reference? Type embedding with Go interfaces

Interface embedding to add minor features

A Go error handling idiom It's time to run our program

Summary

Adding Functionality with Decoration

Interface composition

Go's complimentary Reader and Writer interfaces

Example usages of the Reader and Writer interfaces

Design with Duck Typing

More reasons to design using interfaces

Using the Reader and Writer interfaces

Decorator pattern

Type hierarchy UML How Procedural design compares to functional Inversion of Control (IoC)

Procedural design example Functional IoC example

A decorator implementation

The main.go file The decorator/simple_log.go file

Example InitLog calls Back to our main package Understanding our statistics using the easy-metrics GUI

Quick look at the Dot Init update Easy-metrics - 1 of 3

The decorator/decorator.go file

A framework to inject dependencies

Wrapping a client request with decorators (in main)

Authorization decorator Logging decorator LoadBalancing decorator

Strategy pattern Inversion of control and dependency injection Our first failure Easy metrics - 2 of 3 Groking our trace log file

The rest of the graph

Easy metrics - 3 of 3

Examining the trace log

The decorator/requestor.go file

The job variable declared in main() Back to the requestor.go file Using channels to manage the life cycle All requests done Launching our makeRequest goroutine Our DI framework in action

Summary

Applying FP at the Architectural Level

Application architectures

What is software architecture? Client-server architecture Cloud architecture Why does architecture matter?

The role of systems engineering

Real systems IT system specialty groups Systems engineering is lean Requirements, scope and terms

Defining terms

Software requirements System System architecture System elements System Boundaries

Managing Complexity

The best tool for the job Divide and conquer Designing for state management

Add a microservice

FP influenced architectures Domain Driven Design

Dependency rule

Cyclic dependency

Working code Code with cyclic dependency error The Golang difference

Solution for cyclic dependencies

Domain Driven Design

Interface-driven development Hollywood principle

Observer pattern Dependency injection

A cloud bucket application

Directory structure

main.go func HandlePanic

Dependency injection

func main()

Layers in the architecture

Domain layer Use cases layer

Compatible interfaces

Interfaces layer

Why global variables are bad Format the response Testing our interfaces

Infrastructure layer

Context object

Benefits of DDD

Adaptability Sustainability Testability Comprehensibility

A solid architectural foundation

FP and Micyoservices

Message passing

All parties must participate

Communication across boundaries

Polyglot Persistence

Lambda architecture

Speed Batch Servicing Next generation big data architecture

CQRS

Benefits of CQRS

Infrastructure architecture Share nothing architecture Integrating services

Agreed upon protocol Circuit breakers

Functional reactive architecture Go is ideal for building microservices

Size matters Benefits of gRPC Who is using Go?

Summary

Functional Parameters

Refactoring long parameter lists

What's wrong with a function signature with more than seven parameters? Refactoring - the book Edsger W. Dijkstra says OOP is a bad idea

What else did Edsger W. Dijkstra say? The underlying OOP problem OOP inconsistency Functional programming and cloud computing

A closer look at f(x)

A closer look at refactoring

Passing every parameter a function requires to do its job is not a good idea Methods can query other objects' methods internally for data required to make decisions Methods should depend on their host class for needed data Pass a whole object with required attributes to reduce the number of required parameters Replace parameter with method technique to reduce the number of required parameters

Before applying Replace Parameter with Method technique After applying Replace Parameter with Method technique

Use a parameter object when we have unrelated data elements to pass Long parameter lists will change over time and are inherently difficult to understand

The solution

Three ways to pass multiple parameters

Simply passing multiple parameters Passing a configuration object/struct that contains multiple attributes Partial application

Functional parameters Contexts

Context limitations

Report example

Writing good code is not unlike a good game of soccer

Functional parameters - Rowe Report example

A more practical Context use case

src/server/server.go The src/server/server_options.go file

Summary

Increasing Performance Using Pipelining

Introducing the pipeline pattern

Grep sort example Pipeline characteristics Examples

Website order processing Boss worker pattern Load balancer Data flow types

Building blocks

Generalized business application design

Example implementations

Imperative implementation

Decrypt, authenticate, charge flow diagram

Concurrent implementation Buffered implementation

Leverage all CPU cores

Improved implementation

Imports BuildPipeline Immediately executable Goroutine Receive order Filterer interface A Filterer object Authenticate filter Decrypt filter

Complete processing The ChargeCard helper function

Charge filter The encrypt and decrypt helper functions

Testing how the application handles invalid data

Invalid credit card cipher text Invalid password Changing the order of authenticate and decrypt filters Attempting to charge before decrypting credit card number and authentication Attempting to charge before authentication