Personal Information
Organization / Workplace
London, United Kingdom United Kingdom
Occupation
Software development is what I am passionate about
Industry
Technology / Software / Internet
Tags
functional programming
scala
fp
haskell
monad
flatmap
fold
recursion
folding
right fold
left fold
map
functor
foldright
composition
foldleft
list
java
foldr
for comprehension
monoid
unit
bind
foldl
kleisli composition
function composition
side effect
séquence
applicative
category theory
option
iterate
mathematical induction
semigroup
cats
traverse
io monad
pure function
pure
refactoring
tail recursion
foldmap
applicative functor
effectful function
iteration
left scan
scan
richard bird
recursive datatype
recursive function
graham hutton
foldable
fp in scala
scalaz
join
fish operator
effectful
filter
combinatorial-puzzle
n-queens
graphics
streams
structural induction
side-effecting
game of life
option monad
adt
algebraic data type
scala 3
identity
sicp
return
flatten
effect
infinite list
iterating
scanning
right scan
fold right
fold left
accumulator trick
tail-recursion
cats effect
polyglot fp
will kurt
impure function
product type
point
state monad
paul chiusano
functional effect
abstraction
combinators
martin fowler
robert martin
kleisli
syntactic sugar
oo
lists
natural numbers
sieve of eratosthenes
prime numbers
algorithms
sealed interface
scheme
imperative programming
combinatorial
recursive algorithm
lazy
eager
call-by-name
call-by-value
performance
complexity
sergei winitzki
induction
runar bjarnason
alejandro serrano mena
list monad
identity monad
scott wlaschin
f#
enum
sum type
martin odersky
type classes
strict
monad composition
combine
assignment
structure and interpretation of computer programs
referential transparency
typeclass
ap
composite
domain driven design
associativity
procedural programming
raymond smullyan
polymorphism
monad transformer
design
structured programming
tdd
natural transformation
functor laws
type constructor
programming
stream
lambda calculus
universal property of fold
data oriented programming
haskell curry
combinatorial logic
uncle bob
gerald jay sussman
harold abelson
asd: ppp
clean code
drawing
device coordinate
logical coordinate
frame
panel
canvas
axes
coordinates
device
logical
computer graphics
oop
sealed trait
case class
text block
record
improving the design of code
code
javascript
reduce
permutations
foldm
filterm
mapm
clojure
imperative functional programming
intercalate
intersperse
mathematical definition
withfilter
guard
functional-programming
scala-3
monadplus
list-comprehension
do-expression
for-comprehension
immediate mode
retained mode
sierpinski
sierpinski triangle
space leak
innermost-reduction
outermost reduction
evaluation order
redex
strictness
nonstrict
lazy evaluation
sfoldl
foldl'
initial segments
inits
fibonacci
tupling
loop
sequences
scanright
scanleft
scanr
scanl
nil
cons
reverse
big o notation
duality theorems of fold
훩-notation
asymptotic analysis
duality theorems
unison
combinator
kleisli arrow
monadic law of associativity
none
some
functional data structure
opaque type
f sharp
enumeration
ddd
or type
and type
extension methods
unison language
*>
<*>
validation applicative
right-shark
right-bird
validation
state
traversable
implicits
subtype polymorphism
compose
>=>
swap
functor composition
future
fpis
mutation
lisp
substitution model
sam halliday
higher kinded types
apply
writer monad
design patterns
monad laws
point-free stye
test driven development
mappend
ocp
open closed principle
homomorphism
kleisli category
effectful computation
coupling
single responsibility principle
cohesión
kent beck
inheritance
lambda
java 8
horner’s rule
programmatic definition
natural
nature
traversefilter
factorial
monadic triad
triad
iterative algorithm
monoidal functions
parallelisable collection
parallelisable operation
parallel collections
parallel
sequential
aggregate
reduceleft
genuine sieve
unfaithful sieve
faithful sieve
infinite lists
java 19
or
and
mathematical expression
brian goetz
coproduct
sealed class
record type
pattern matching
algebraic data types
courage
truth
potential
human purpose
pursuit of meaning
ethical axiom
evil
good
expediency
meaning
jordan peterson
robert c. martin
call-by-need
memoized
lazy val
def
val
empty-paren method
parameterless method
uniform access principle
square
triangle
ad-hoc polymorphism
class-based polymorphism
alternation-based polymorphism
liskov substitution principle
lsp
object-oriented programming
expression problem
java 17
multiline string
jdk17
immutable
mutable
immutability
mutability
sequential-access
random-access
iterable
seq
listbuffer
arraybuffer
arraylist
linkedlist
buffer
array
collections
tree
accumulate
io actions
program structure flowchart
impure functions
pure functions
functional core
imperative shell
combinatorial-problem
prolog
logic programming
sorting
algorithm
quicksort
doodle
divide-and-conquer
self-similarity
introduction to fp using haskell
the science of functional programming
formula
definition
applicative style
function functor
io applicative
list applicative
maybe applicative
io functor
list functor
maybe functor
function applicative
palindrome
fmap
functor identity law
option adt
identity function
code kata
trampolining
trampoline
monadic code
continuation
scala language
unison abilities
ability
algebraic effect
monadic effect
monadic composition
block notation
do notation
binding
variable
statement
imperative program
effect composition
reader monad
functor law
algebraic type system
dotty
givens
append-only codebase
never broken codebase
always live codebase
easy renaming
cached test results
no builds
scream operator
julie moronuki
chris martin
effect zoo
either
io
reader
writer
monadic
immutable data type
side effecting
exception
latency
try
capability
symmetry
subtype
subclassing
object oriented programming
pimp my library pattern
extends
syntax class
summoner
context bound
ad hoc polymorphism
type class
lambda expression
closure
function literal
function expression
anonymous function
lambda function
being without
vanity
happiness
bertrand russell
backward composition
forward composition
non-strict functions
strict functions
bottom
by-name
by-value
non-strict
extreme programming explained
red-green-refactor cycle
simple design
test-driven-development
kentbeck
extreme programming
xp
class cohesion
math
static methods
class methods
encumbrance
mixed-domain cohesion
logical cohesion
coincidental cohesion
object
singleton
utility
>>=
nested monads
applicative composition
monad trait
comprehension
concatenate
tie interceptor
hkts
semigroupk
monoidk
option monoid
endomonoid
smells
shotgun surgery
divergent change
cohesion srp
bad smells in code
typeclass coherence
monoid canonicity
monoid laws
identity element
zero
mempty
monoid dual
environment model
abelson
sussman
inculpability
purity
totality
determinism
fp for mortals with scalaz
generic code
hkt
apply3
apply2
map3
map2
for
embellished function
alvin alexander
bartosz milewski
universal abstraction
composite design pattern
mark seemann
humane code
clean coders
science
tractatus logico-philosophicus
wittgenstein
philosophy
logic
gang of four
christopher alexander
composite pattern
metis
pattern language
right identity
monadic laws
left identity
hipster code
domain modelling
combinator birds
to mock a mocking bird
blackbird
combinatory logic
tacit code
pointful style
dynamic polymorphism
dependecy inversion
object oriented
implicit functions
kleisli triples
better design
diagnostics
true
design qualities
design smells
code goodness
principles
functional decomposition
testing
edsger wybe dijkstra
naturality condition
endofunctor
lifting
design smell
agile design
isomorphism
compositionality
effects
simple io monad fp functional programming scala
fp scala foldleft foldright reduce
logic monoid functional programming scala demorgan
srp
fp combinators clojure functional programming
refactoring code smell coupling cohesion
oaoo dry once and only once xp extreme programming
srp single responsibility principle
lambda expressions
higher order functions
expedia worldwide engineering
first class functions
open closed principle ocp dip lsp software design
class inheritance interface inheritance
style
smalltalk
patterns
allen holub
sandi metz
principle
open-closed
ocp open-closed bertrand meyer software design pri
functions
functional
strams
See more