Index
A
- abstract syntax tree (AST) / Minggatu - Catalan number
- Aggregate method
- reference / Nums revisited
- Alan Turing / Alan Turing (1950)
- Alfred Whitehead / Alfred Whitehead and Bertrand Russell (1903)
- algebra
- about / Algebra and the unknown
- rules / Algebra and the unknown
- real-world application / Real-world application of algebra
- laws / Basic laws of algebra
- Alonzo Church / Alonzo Church (1930, 1940)
- alternative workflow option / An alternative workflow option
- annotations / The clipperhouse/gen tool
- anonymous function
- and closure, differentiating between / The difference between an anonymous function and a closure
- application architectures
- about / Application architectures
- reference / Application architectures
- functionality / Application architectures
- performance / Application architectures
- scalability / Application architectures
- importance / Why does architecture matter?
- application programming interfaces (APIs) / Interface-driven development
- Aspect-Oriented Programming (AOP) / Solve lack of generics with metaprogramming
- Augustus De Morgan / Augustus De Morgan (1806 - 1871)
- authenticate and decrypt filters
- charging, before credit card number decryption / Attempting to charge before decrypting credit card number and authentication
B
- base class
- Int base class / Int base class
- string base class / String base class
- main.go file / Our main.go file
- sum parent type class / Sum parent type class
- sum base class / Sum base classes
- Bash commands
- piping / Piping Bash commands
- benchmark test
- for SumRecursive function / Benchmark test for the SumRecursive function
- Bertrand Russell / Alfred Whitehead and Bertrand Russell (1903)
- Big-Oh notation / Big-Oh notation
- big data / Big data, knowledge-driven development, and data visualization
- boilerplate code
- for lack of generics / No Generics results in a lot of boilerplate code
- buffered implementation, pipeline pattern
- CPU cores, leveraging / Leverage all CPU cores
- business use case
- scenarios / Business use case scenarios
C
- car functor
- about / The car functor
- package / The functor package
- main.go file / main.go
- one line of FP, comparing to bunch of imperative lines / Compare one line of FP to a bunch of imperative lines
- example, executing / Car functor terminal session
- category
- about / A Category
- axioms / Category axioms
- laws / Category laws
- rules / More rules
- examples / Invalid categories
- invalid categories / Invalid categories
- category theory
- about / Our goal, Category theory, A review of Category theory
- as algebra of functions / Algebra of functions
- abstract functions / Abstract functions
- function, defining / Official definition of a function
- function, intuitive definition / Intuitive definition of a function
- function composition, with sets / Function composition with sets
- composition operation example, using travel expenses / Composition operation example using travel expenses
- elements / A Category
- using / Using mathematics and category theory to gain understanding
- cd command
- for projecting root directory / The cd command to project root directory
- chapter4 application code
- about / The chapter4 application code, More application code
- build and runtime instructions / Build and runtime instructions
- Filter function / The Filter function, Filter function
- FilterFunc / FilterFunc
- Charles Lutwidge Dodgson / Charles Lutwidge Dodgson (1832 –1898)
- clipperhouse/gen tool
- about / The clipperhouse/gen tool
- generics, supported by GO / If Go supported generics
- new methods, adding / Adding new methods
- filter function, defining / Defining a filter function
- closure rule, monoid
- examples / Closure rule examples
- axiom / Closure axiom
- codomain / Domains, codomains, and morphisms, A Category
- collection
- iterating through / Iterating through a collection
- collection of cars
- iterating over / Iterating over a collection of cars
- empty interface / The empty interface
- Contains() method / The Contains() method
- composable concurrency
- about / Composable concurrency
- finite state machines / Finite state machines
- composition operation
- about / Composition operation
- example, in Go / Composition example in Go
- Haskell version / Haskell version of compose
- (g.f)(x) = g(f(x)) composition, in Go / (g.f)(x) = g(f(x)) composition in Go
- (g.f)(x) = g(f(x)) composition, implementing / The (g.f)(x) = g(f(x)) implementation
- naming conventions / A note about composition naming conventions in Go
- arrow directions / The directions of the arrows are significant
- incorrect order of EmphasizeHumanize / EmphasizeHumanize ordered incorrectly
- function composition, as associative / Function composition is associative
- concurrency
- managing, WaitGroup variable used / Using a WaitGroup variable to manage concurrency
- container orchestrator
- reference / Functional programming and cloud computing
- contains / Contains
- contexts
- about / Contexts
- reference / Contexts
- limitations / Context limitations
- report example / Report example, Report example
- good code, writing / Writing good code is not unlike a good game of soccer
- functional parameters / Functional parameters - Rowe
- use case / A more practical Context use case
- src/server/server.go / src/server/server.go
- src/server/server_options.go file / The src/server/server_options.go file
- converse of a conditional proposition
- about / Converse of a conditional proposition
- orders / Order matters
- credit card number
- charging, before authentication / Attempting to charge before authentication
- Curry-Howard-Lambek (CHL) Correspondence / Curry-Howard-Lambek Correspondence (1969)
- Curry Howard Isomorphism
- about / The Curry Howard isomorphism
- examples, of propositions / Examples of propositions
- examples, of not propositions / Not propositions
- Lambda calculus / Lambda calculus
- currying
- about / A closer look at currying
- example / Extending our currying example, Partial application
- customer relationship management (CRM) / Cloud architecture
- cyclic dependency
- about / Cyclic dependency
- working code / Working code
- error code / Code with cyclic dependency error
- Golang difference / The Golang difference
- solution / Solution for cyclic dependencies
D
- data visualization / Data visualization
- declarative programming / Imperative versus declarative programming
- decorator.go file
- framework, for injecting dependencies / A framework to inject dependencies
- client request, wrapping up with decorators / Wrapping a client request with decorators (in main)
- authorization decorator / Authorization decorator
- Logging decorator / Logging decorator
- LoadBalancing decorator / LoadBalancing decorator
- graph / The rest of the graph
- trace log, examining / Examining the trace log
- decorator pattern
- about / Decorator pattern
- type hierarchy UML / Type hierarchy UML
- implementation / A decorator implementation
- main.go file / The main.go file
- simple_log.go file / The decorator/simple_log.go file
- decorator.go file / The decorator/decorator.go file
- requestor.go file / The decorator/requestor.go file
- Decrypt filter
- complete processing / Complete processing
- ChargeCard helper function / The ChargeCard helper function
- Dependency Injection (DI) / Inversion of control and dependency injection
- dependency injection, Onion Architecture
- about / Dependency injection
- func() main / func main()
- dependency rule
- cyclic dependency / Cyclic dependency
- design document
- creating / Creating a design document
- development workflow
- about / Development workflow summary
- dot Init, troubleshooting / Troubleshooting dot init
- directed acyclic graph (DAG) / Gleam - distributed MapReduce for Golang
- directory structure, Onion Architecture
- main.go / main.go
- func HandlePanic / func HandlePanic
- Domain-Specific Languages (DSLs) / Solve lack of generics with metaprogramming
- domain entities / Domain Driven Design
- domains / Domains, codomains, and morphisms
- duck typing
- about / Duck typing
- design / Design with Duck Typing
E
- Eilenberg / MacLane and Eilenberg (1945)
- elite player (EP) / Writing good code is not unlike a good game of soccer
- empty interface-based Map function
- endomorphism / Endomorphism
- environment
- variables, reference / Functional parameters
- about / The lift operation
- error handling / Digging deeper into error handling
- example proposal / An example proposal
- examples, quadratic equations
- about / More examples of quadratic equations
- golden ratio / The golden ratio
F
- f(x) / A closer look at f(x)
- FantasyLand JavaScript specification
- about / FantasyLand JavaScript specification
- Setoid algebra / Setoid algebra
- Ord algebra / Ord algebra
- FaultTolerance / Dependency injection
- Feature Oriented Software Development (FOSD) / Open / close principle in functional programming
- Fibonacci sequence / Fibonacci sequence - a simple recursion and two performance improvements
- filter function / Map and filter
- first in, first out (FIFO) / Iterating through a collection
- forgetful functor
- and law / The forgetful functor and the law
- rule of law / The rule of law
- about / Lucy’s forgetful functor
- Forth language / The Forth language
- functional composition
- about / Functional composition in the context of a legal obligation
- state transitions, determining / Decisions determine state transitions
- category theory, review / Category theory review
- category theory, rules / Categorical rules
- category theory, result oriented / Results oriented
- forgetful functor / The forgetful functor and the law
- functional Inversion of Control (IoC)
- procedural design / How Procedural design compares to functional Inversion of Control (IoC)
- example / Functional IoC example
- functional packages / Functional packages
- functional parameters / Functional parameters
- functional programming (FP)
- motivation / Motivation for using FP
- source files, directory structure / The directory structure of the source files
- concurrency constructs, using / FP using Go's concurrency constructs
- characteristics / Characteristics of FP
- generics / Generics
- first-class functions / First-class functions
- closure / Closure
- immutable state / Pure function
- expressions, using / Use of expressions
- functional programming / Functional programming and cloud computing
- history, in nutshell / The history of FP in a nutshell
- reference / Where to go from here
- resources / FP resources
- function literals
- about / A time of reckoning
- example / A quick example of a function literal
- function signature, with more than seven parameters
- functions that modify functions
- about / Functions that modify functions
- coding example /
- visual example / A visual example of functions that modify functions
- composition in Mindcraft / Composition in Mindcraft
- functors
- about / Functors, Various intermediate and terminal functions , Understanding functors, A magical structure
- Reduce example / Reduce example
- intermediate functions / Intermediate functions
- terminal functions / Terminal functions
- imperative, versus pure FP example / An imperative versus pure FP example
- map function / What did that Map function do for us?
- benefits, of using map function / What possible benefits can this afford us?
- color blocks functor / Color blocks functor
- fingers times 10 functor / Fingers times 10 functor
- defining, in Haskell / Definition of a functor in Haskell
- types / Kinds of types
- shape / The shape of a functor
- implementation / Functor implementation
- implementing, with ints functors / ints functor
- definition / Functor definition
- identity operations / Identity operation
G
- Gang of Four (GOF) / Using the Reader and Writer interfaces
- gen
- reference / The clipperhouse/gen tool
- GenerateCars function
- finishing up / Finishing up the GenerateCars function
- generics
- reference / Generics implementation options
- about / Generics revisited
- generics code generation tool
- about / Generics code generation tool
- clipperhouse/gen tool / The clipperhouse/gen tool
- nums / Nums revisited
- Gibbons / Gibbons, Oliveira (2006)
- Gleam
- about / Gleam - distributed MapReduce for Golang
- LuaJIT, FFI library / LuaJIT's FFI library
- Unix pipe tools / Unix pipe tools
- collections, processing / Processing Gleam collections
- reality check / Reality check
- Glide
- glide-update
- executing, for obtaining third-party dependency files / Running glide-update to get third-party dependency files
- Go
- application, executing / How to run our first Go application
- installation link / How to run our first Go application
- reference / Map and filter
- generics / If Go had generics
- map function / Map function
- functional programming style / Another time of reflection
- advantages / Go is awesome
- disadvantages / Go is awesome, but
- distributed computing solution, implementing / The cure
- error handling idiom / A Go error handling idiom
- Reader and Writer interfaces / Go's complimentary Reader and Writer interfaces
- Reader and Writer interfaces, examples / Example usages of the Reader and Writer interfaces
- changes, proposing / How to propose changes to Go
- specs, searching / The first step - search specs
- Google search / Second step - Google search
- Go dependencies
- managing, with go get tool / The go get tool
- managing, with godep tool / The Godep tool
- vendoring / Vendoring in Go
- Glide / Glide - the modern package manager
- Go dependency management
- reference / A note about Go Dependency Management
- goenv
- reference / Motivation for using goenv
- updated scenarios, displaying / The goenv shows what's been updated
- Go interfaces
- used, for type embedding / Type embedding with Go interfaces
- Golang / Impact of Golang
- golang-dev group
- notifying, by sending email / Sending an email to notify the golang-dev group
- Golang change proposal process
- reference / The official Golang change proposal process
- existing Issues, searching for / Search for existing issues
- existing proposals, reading / Reading existing proposals
- comment, adding to existing TCO proposal / Adding a comment to the existing TCO proposal
- Go projects
- building / How to build and run Go projects
- executing / How to build and run Go projects, TL;DR
- development workflow / Development workflow
- dot init features / Dot init features and benefits
- goenv, using / Motivation for using goenv
- init script, using / Motivation for using the init script
- dependencies, managing / Ways to manage Go dependencies
- dot init step / Each dot init step in detail
- standard library imports, adding / Adding standard library imports
- third-party imports, adding / Adding third-party imports
- Go proverbs
- reference / Interface-driven development
- Gorilla's package
- reference / Contexts
- Goroutine
- currying / Currying Goroutine
- graph database
- example / Graph Database Example
H
- 12-hour clock functor
- building / Build a 12-hour clock functor
- helpers / Clock functor helpers
- Haskell
- reference / The lift operation, Haskell
- type classes / Type classes in Haskell
- Haskell Curry / Haskell Curry - 1927
- helpers, 12-hour clock functor
- Unit function / The Unit function
- AmPmMapper function / The AmPmMapper function
- AmHoursFn helper / The AmHoursFn helper
- String helper function / The String helper function
- main.go / main.go
- terminal output log / Terminal output log
- summary / Functor summary
- high-order functions (HOF) / Characteristics of FP
- historical events, functional programming / Historical Events in Functional Programming, Augustus De Morgan (1806 - 1871), Friedrich Ludwig Gottlob Frege (1848 – 1925), Charles Lutwidge Dodgson (1832 –1898), Alfred Whitehead and Bertrand Russell (1903), Moses Schonfinkel (1889–1942), Haskell Curry - 1927, Gerhard Gentzen (1936), Alonzo Church (1930, 1940), Alan Turing (1950), MacLane and Eilenberg (1945), John McCarthy (1950), Curry-Howard-Lambek Correspondence (1969), Roger Godement (1958), Moggi, Wadler, Jones (1991), Gibbons, Oliveira (2006)
- HOF application
- about / Sample HOF application
- chapter4 application code / The chapter4 application code
- RESTful resources / RESTful resources
- example / The final HOF example
- homebrew
- used, for installing Go / Using homebrew to install Go
- homomorphism
- about / Homomorphism
- preserve correspondence / Homomorphisms preserve correspondence
- encryption / Homomorphic encryption
- categories / Homomorphism table
- car crash analogy / Car crash analogy
- homomorphism encryption
- about / Homomorphic encryption
- example / An example of homomorphic encryption
I
- identity rule, monoid
- examples / Identity rule examples
- identity of 0 / An identity of 0
- Immersive Railroad application
- reference / Composition in Mindcraft
- imperative implementation, pipeline pattern
- charge flow diagram / Decrypt, authenticate, charge flow diagram
- imperative programming
- versus declarative programming / Imperative versus declarative programming
- about / Imperative versus declarative programming
- imperative SumLoop function
- benchmark test / Benchmark test for the imperative SumLoop function
- improved implementation
- imports / Imports
- BuildPipeline / BuildPipeline
- executable Goroutine / Immediately executable Goroutine
- order, receiving / Receive order
- Filterer interface / Filterer interface
- Filterer object / A Filterer object
- Authenticate filter / Authenticate filter
- Decrypt filter / Decrypt filter
- Charge filter / Charge filter
- encrypt helper functions / The encrypt and decrypt helper functions
- decrypt helper function / The encrypt and decrypt helper functions
- inference
- reference / Gerhard Gentzen (1936)
- infrastructure layers, Onion Architecture
- about / Infrastructure layer
- context object / Context object
- init, features
- aliases / Aliases available
- functions / Functions available
- initial directory structure and files
- init script
- contents / The init script contents
- executing / Running the init script
- interface composition / Interface composition
- interface layers, Onion Architecture
- about / Interfaces layer
- global variables, limitations / Why global variables are bad
- response, formatting / Format the response
- interface, testing / Testing our interfaces
- interfaces
- used, for creating design / More reasons to design using interfaces
- intermediate functions
- about / Various intermediate and terminal functions , Intermediate functions
- map / Common intermediate functions
- filter / Common intermediate functions
- sort / Common intermediate functions
- mapping example / Map Example
- InternationalizatioN (I18N) package / InternationalizatioN (I18N) package
- invalid data, handling
- about / Testing how the application handles invalid data
- invalid credit card cipher text / Invalid credit card cipher text
- invalid password / Invalid password
- authenticate and decrypt filters, order change / Changing the order of authenticate and decrypt filters
- attempt to charge, before credit card number decryption / Attempting to charge before decrypting credit card number and authentication
- credit card charging attempt, before authentication / Attempting to charge before authentication
- invariant / This OOP method stinks
- Inversion of Control (IoC) / Inversion of control and dependency injection
- isomorphism / Isomorphism
- Itertools
- about / Itertools
- Go channels, used by new function / Go channels used by the New function
- map function, testing / Testing itertool's Map function
- iterators, testing for element equality / Testing iterators for element equality
J
- Java
- loathing / Why many Gophers eschew Java
- loathing, reasons / More reasons for eschewing Java
- John McCarthy / John McCarthy (1950)
- Jones / Moggi, Wadler, Jones (1991)
K
- Keep It Simple Stupid-Glide (KISS-Glide) / The main.go file, Quick look at the Dot Init update
- knowledge-driven development / Big data, knowledge-driven development, and data visualization
L
- Lambda calculus
- about / Lambda calculus, Haskell Curry - 1927, The Lambda Calculus
- formalism / Why so formal?
- importance of protocol / The importance of protocol
- reference / Lambda expression ingredients
- lambda expressions
- about / Lambda Expressions
- type inference / Anonymous function example and type inference
- anonymous function example / Anonymous function example and type inference
- reference / Anonymous function example and type inference
- contents / Lambda expression ingredients
- visualizing / Visualizing a lambda expression
- describing / A Lambda calculus is like chocolate milk
- in other languages / Lambda examples in other languages
- in JavaScript / JavaScript
- in JavaScript (ES6) / JavaScript (ES6)
- in Ruby / Ruby
- building, with laws of exponentials / Laws of exponentials for building a lambda expression
- lambda lifting / ints functor
- Language Integrated Query (LINQ) / The LINQ language
- laws of exponentials
- for building lambda expression / Laws of exponentials for building a lambda expression
- table legend / Table legend
- isomorphic equations / Sums and products, Isomorphic equations
- layers, Onion Architecture
- use cases layer / Use cases layer
- interfaces layer / Interfaces layer
- infrastructure layer / Infrastructure layer
- lazy evaluation / Intermediate functions
- Liskov substitution principle
- about / Liskov substitution principle
- OOP method / This OOP method stinks
- FP function / Our FP function smells like roses
- code example / In FP, contracts don't lie
- duck typing / Duck typing
- inheritance / What can go wrong with inheritance?
- interface segregation principle / Interface segregation principle
- dependency inversion principle (DIP) / Dependency inversion principle
- LoadBalancing decorator
- about / LoadBalancing decorator
- strategy pattern / Strategy pattern
- Inversion of Control (IoC) / Inversion of control and dependency injection
- dependency injection / Inversion of control and dependency injection
- first failure / Our first failure
- easy-metrics graph / Easy metrics - 2 of 3
- trace log file, groking / Groking our trace log file
- logical connectives
- about / Logical connectives
- function / Logical inconsistency
- partial function / Partial function
- long parameter lists
- refactoring / Refactoring long parameter lists, Refactoring - the book
M
- MacLane / MacLane and Eilenberg (1945)
- Map function
- about / Map and filter, The Map function
- performance / Improved performance from the Map function
- MapReduce
- about / MapReduce
- example / MapReduce example
- mathematics
- correspondence / Correspondence in mathematics
- using / Using mathematics and category theory to gain understanding
- maybe functor / Maybe
- memoization
- using / Memoization
- about / Intermediate functions
- metaprogramming (MP)
- used, for solving lack of generics / Solve lack of generics with metaprogramming
- methods / An OOP example
- Minggatu-Catalan Number / Minggatu - Catalan number
- Modus Ponens
- about / Modus Ponens
- type theory version / Type theory version
- logic version / Logic version
- Moggi / Moggi, Wadler, Jones (1991)
- monad
- about / The big reveal, Roger Godement (1958)
- activities / What else can Monads do?
- monadic functions
- fail / Monadic functions
- fmap / Monadic functions
- mplus / Monadic functions
- mzero / Monadic functions
- return / Monadic functions
- forM / Basic monadic functions
- forever / Basic monadic functions
- mapM / Basic monadic functions
- sequence / Basic monadic functions
- void / Basic monadic functions
- monadic list functions
- filterM / Monadic list functions
- foldM / Monadic list functions
- join / Monadic list functions
- msum / Monadic list functions
- replicateM / Monadic list functions
- zipWithM / Monadic list functions
- monadic workflow implementation
- about / Monadic workflow implementation
- Lambda Calculus / Lambda calculus
- Monads, Haskell
- Error / The lift operation
- Eval / The lift operation
- Failure / The lift operation
- Free / The lift operation
- Identity / The lift operation
- If / The lift operation
- Lazy / The lift operation
- IO / The lift operation
- List / The lift operation
- Maybe / The lift operation
- Option / The lift operation
- Par / The lift operation
- Parser / The lift operation
- Pause / The lift operation
- Reader / The lift operation
- State / The lift operation
- ST / The lift operation
- Software Transactional Memory (STM) / The lift operation
- Writer / The lift operation
- monoid
- about / Monoids
- rules / Monoid rules
- reduction function, writing / Writing a reduction function
- semigroup / A semigroup is a missing neutral value
- referential transparency / Referential transparency
- no data, handling / Handling no data
- examples / More examples of monoids, Monoid examples
- not monoids / What are not monoids?
- name monoid / Name monoid
- morphism
- about / Domains, codomains, and morphisms, Morphisms, More morphisms
- behaviors / The behaviors of morphisms
- composition operation / Composition operation
- identity operation / Identity operation
- law of associativity / Law of associativity
- focusing on / Only concerned with morphisms
- interface-driven development / Interface-driven development
- correspondence / Even more correspondence
- operations / Table of morphisms
- examples / Morphism examples
- correspondence, between logic and type theory / Correspondence between logic and type theory
- cartesian closed category (CCC) / Cartesian closed category
- unit type / Unit type
- injective morphism / Injective morphism
- subjective morphism / Surjective morphism
- Moses Schonfinkel / Moses Schonfinkel (1889–1942)
- Mother Teresa Monad
- about / Mother Teresa Monad
- bind operation / The bind operation
- lift operation / The lift operation
- multiple parameters
- passing, ways / Three ways to pass multiple parameters
- simply pass / Simply passing multiple parameters
- configuration object/struct, passing / Passing a configuration object/struct that contains multiple attributes
- partial application / Partial application
N
- name monoid
- about / Name monoid
- terminal session / Name monoid terminal session, Int slice monoid
- Lineitem slice monoid / Lineitem slice monoid
- Int slice monoid terminal session / Int slice monoid terminal session
- new proposal
- creating / Creating a new proposal
- non-functional requirements (NFRs) / Motivation for using FP
O
- Object-Oriented Programming (OOP)
- about / SOLID design principles, An OOP example
- limitation / Edsger W. Dijkstra says OOP is a bad idea
- issue / The underlying OOP problem
- inconsistency / OOP inconsistency
- cloud computing / Functional programming and cloud computing
- Object Relational Mapping (ORM) / Ruby
- Oliveira / Gibbons, Oliveira (2006)
- Onion Architecture
- client-server architecture / Client-server architecture
- cloud architecture / Cloud architecture
- dependency rule / Dependency rule
- use cases / Domain Driven Design
- using / Domain Driven Design
- domain statement / Domain Driven Design
- infrastructure / Domain Driven Design
- interface-driven development / Interface-driven development
- hollywood principle / Hollywood principle
- observer pattern / Observer pattern
- dependency injection (DI) / Dependency injection
- about / A cloud bucket application
- directory structure / Directory structure
- dependency injection / Dependency injection
- layers / Layers in the architecture
- open/closed principle
- about / Open/closed principle
- in functional programming / Open / close principle in functional programming
- FantasyLand JavaScript specification / FantasyLand JavaScript specification
- expression problem / The expression problem
- options, for implementing generics
- about / Generics implementation options
- gen tool / We used the gen tool
P
- package errors
- reference / Domain layer
- partial application / Partial application
- paths / A note about paths
- pipeline pattern
- about / Introducing the pipeline pattern
- grep sort example / Grep sort example
- characteristics / Pipeline characteristics
- advantages / Pipeline characteristics
- disadvantages / Pipeline characteristics
- examples / Examples
- website order processing / Website order processing
- load balancer / Load balancer
- data flow types / Data flow types
- generalized business application design / Generalized business application design
- example implementations / Example implementations
- imperative implementation / Imperative implementation
- concurrent implementation / Concurrent implementation
- buffered implementation / Buffered implementation
- improved implementation / Improved implementation
- invalid data handling, by application / Testing how the application handles invalid data
- reference / Further reading
- Pod
- reference / Functional programming and cloud computing
- polymorphism
- at higher level / Polymorphism at a higher level
- post conditions / This OOP method stinks
- precondition / This OOP method stinks
- predicates
- about / Predicates
- reflection / Reflection
- combinator pattern / Combinator pattern
- problem
- splitting up / Break it down
- procedure design
- comparing, to functional Inversion of Control (IoC) / How Procedural design compares to functional Inversion of Control (IoC)
- example / Procedural design example
- programming language
- categories / Programming language categories
- imperative category / Programming language categories
- declarative category / A declarative example
- imperative example / An imperative example
- first generation (1GL) language / Five generations of languages
- 2GL / Five generations of languages
- 3GL / Five generations of languages
- 4GL / Five generations of languages
- 5GL / Five generations of languages
- type systems / Type systems
- programming paradigms
- Venn diagram / Venn diagram of four programming paradigms
- proof theory
- about / Proof theory
- logical connectives / Logical connectives
- truth table / Truth table
- proposal
- pure functions
- about / Pure functions
- characteristics / Pure functions
- referential transparency / Pure functions
- idempotence / Pure functions
R
- Reader and Writer interfaces
- real-world application, algebra
- about / Real-world application of algebra
- linear equation / Linear equation and the law of demand
- law of demand / Linear equation and the law of demand
- quadratic equations / Quadratic equations all around us, More examples of quadratic equations
- linear and quadratic functions / Function composition with linear and quadratic functions
- reckoning / A time of reckoning
- recursion / The importance of recursion
- recursive function / Fibonacci sequence - a simple recursion and two performance improvements
- Recursive Genome Function
- reference / Lambda calculus
- refactoring
- reflection, Go
- reference / Solve lack of generics with metaprogramming
- Replace Parameter with Method
- requestor.go file
- about / The decorator/requestor.go file, Back to the requestor.go file
- job, declared in main() function / The job variable declared in main()
- channels, used for managing lifecycle / Using channels to manage the life cycle
- request, completing / All requests done
- makeRequest goroutine, launching / Launching our makeRequest goroutine
- DI framework / Our DI framework in action
- RESTful resources
- about / RESTful resources
- chaining functions / Chaining functions
- cars, adding / More cars
- Map function / The Map function
- Reduce functions / The Reduce function
- high-order functions / More high-order functions
- generators / Generators
- RESTful server / RESTful server
- GenerateCars function / The GenerateCars function
- concurrency, handling / Handling concurrency
- Roger Godement / Roger Godement (1958)
- rules, monoid
- closure rule / Closure rule
- associativity rule / Associativity rule
- identity rule / Identity rule
S
- self-referential functions
- reference / The solution
- semaphore lock / The lift operation
- semiGroup homomorphism
- about / SemiGroup homomorphism
- algebra / SemiGroup Homomorphism Algebra
- set theory symbols / Set theory symbols
- simple_log.go file
- about / The decorator/simple_log.go file
- InitLog calls example / Example InitLog calls
- main package / Back to our main package
- easy-metrics GUI, used for explaining statistics / Understanding our statistics using the easy-metrics GUI
- single responsibility principle
- about / Single responsibility principle
- function composition / Function composition
- SINK Cloud Bucket / A cloud bucket application
- slice typewriter
- about / The slice typewriter
- Aggregate[T] / Aggregate[T]
- software architecture / What is software architecture?
- software design
- methodology / Software design methodology
- good design / Good design
- bad design / Bad design
- good, versus bad design over time / Good versus bad design over time
- software product line
- reference / Open / close principle in functional programming
- Software Transactional Memory (STM) / The lift operation
- SOLID design principles
- about / SOLID design principles
- single responsibility principle / Single responsibility principle
- open/closed principle / Open/closed principle
- Liskov substitution principle / Liskov substitution principle
- SOURCE Cloud Bucket / A cloud bucket application
- Sprintf options
- reference / src/server/server.go
- standard construction / Roger Godement (1958)
- standard library imports
- adding / Adding standard library imports
- Go standard library / The Go standard library
- State Thread (ST) monad / The lift operation
- SumRecursive function
- benchmark test / Benchmark test for the SumRecursive function
T
- 4th generation language (4GL) / The LINQ language
- tacit programming
- about / Tacit programming
- with Unix pipes / Tacit programming with Unix pipes
- programming CMOS, with Unix pipes / Programming CMOS with Unix pipes
- with FP / Tacit programming with FP
- tacit programming, with FP
- about / Tacit programming with FP
- non-TCO recursive example / Non-TCO recursive example
- TCO recursive example / TCO recursive example
- tail-call optimization (TCO) / Go is awesome, but, Characteristics of FP, Y-Combinator re-examined
- tail recursion / What is tail recursion?
- terminal functions
- about / Various intermediate and terminal functions , Common terminal functions
- Collect, Join, GroupB / Common terminal functions
- ForEach / Common terminal functions
- Reduce / Common terminal functions
- Join example / Join example
- GroupBy example / GroupBy example
- Reduce example / Reduce example
- test-driven development
- used, for testing FP / Testing FP using test-driven development
- tests
- third-party imports
- statement referencing go_utils, importing / Importing statement referencing go_utils
- toml config file
- reference / Dot init features and benefits
- truth table
- about / Truth table
- conditional propositions / Conditional propositions
- logical equivalence / Logical equivalence
- converse of conditional proposition / Converse of a conditional proposition
- type classes
- about / Type classes
- base class definitions / Base class definitions
- type system implications
- static, versus dynamic typing / Static versus dynamic typing
- type inference / Type inference
- Haskell / Haskell
U
- Unicode Common Locale Data Repository (CLDR)
- reference / InternationalizatioN (I18N) package
- Unified Markup Language (UML) / Software design methodology
- untyped Lambda calculus / Lambda calculus
- use cases layers, Onion Architecture
- about / Use cases layer
- compatible interfaces / Compatible interfaces
V
- Viva La Duck application
- about / Viva La Duck
- pass by reference / Pass by value or reference?
- pass by value / Pass by value or reference?
- executing / It's time to run our program
W
- Wadler / Moggi, Wadler, Jones (1991)
Y
- Y-Combinator
- about / Y-Combinator, Y-Combinator re-examined
- working / How the Y-Combinator works
- Lexical Workflow solution / The Lexical Workflow solution
- not idiomatic / Is our ProcessCar method idomatic Go code?
- idiomatic / The idiomatic parts
- tail recursion / What is tail recursion?
- big-Oh notation / Big-Oh notation