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
map
functor
left fold
folding
right fold
foldright
composition
foldleft
java
foldr
for comprehension
monoid
unit
bind
foldl
kleisli composition
function composition
side effect
séquence
applicative
list
category theory
option
iterate
mathematical induction
semigroup
cats
traverse
io monad
pure function
pure
refactoring
foldmap
applicative functor
effectful function
iteration
left scan
scan
tail recursion
richard bird
graham hutton
foldable
fp in scala
scalaz
join
fish operator
effectful
filter
combinatorial-puzzle
n-queens
graphics
streams
recursive datatype
recursive function
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
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
lists
natural numbers
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
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
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
mathematical definition
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
## Presentations

(118)## Documents

(1)## Likes

(61)### Functional Domain Modeling - The ZIO 2 Way

Debasish Ghosh
•
1 year ago

### Implementing the IO Monad in Scala

Hermann Hueck
•
4 years ago

### Traversals for all ocasions

Luka Jacobowitz
•
5 years ago

### Functional Error Handling with Cats

Mark Canlas
•
3 years ago

### Type Classes in Scala and Haskell

Hermann Hueck
•
5 years ago

### One Monad to Rule Them All

John De Goes
•
4 years ago

### Error Management: Future vs ZIO

John De Goes
•
4 years ago

### Big picture of category theory in scala with deep dive into contravariant and profunctors

Piotr Paradziński
•
4 years ago

### Ten common mistakes made in Function Java

Brian Vermeer
•
5 years ago

### The Death of Final Tagless

John De Goes
•
4 years ago

### Laziness, trampolines, monoids and other functional amenities: this is not your father's Java

Mario Fusco
•
9 years ago

### Refactoring, 2nd Edition

jexp
•
5 years ago

### Functional Algebra: Monoids Applied

Susan Potter
•
11 years ago

### Mtl in 15m

Pere Villega
•
4 years ago

### Wading through treacle? Escape the integration syrup with contract tests

Stefan Smith
•
8 years ago

### Trip with monads

Pawel Szulc
•
5 years ago

### Talking about craftsmanship with ensaimadas and katas

Rachel M. Carmena
•
5 years ago

### Orthogonal Functional Architecture

John De Goes
•
5 years ago

### Bring back Reupload!

Ed Dolan
•
6 years ago

### Bestiary of Functional Programming with Cats

💡 Tomasz Kogut
•
7 years ago

### Real Life Clean Architecture

Mattia Battiston
•
7 years ago

### Object-Oriented Metrics in Practice

Michele Lanza
•
15 years ago

### Ethics - Marketing to Children

krishanthij
•
13 years ago

### Monadic Java

Mario Fusco
•
10 years ago

### SQL Transactions - What they are good for and how they work

Markus Winand
•
7 years ago

### Software craftmanship coaching

Pedro Santos
•
7 years ago

### The Only Way to Test!

Keith Pitty
•
9 years ago

### Code retreat @BMW Car IT

Sebastian Benz
•
12 years ago

### Introduction to software craftsmanship

Alexandru Bolboaca
•
13 years ago

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
map
functor
left fold
folding
right fold
foldright
composition
foldleft
java
foldr
for comprehension
monoid
unit
bind
foldl
kleisli composition
function composition
side effect
séquence
applicative
list
category theory
option
iterate
mathematical induction
semigroup
cats
traverse
io monad
pure function
pure
refactoring
foldmap
applicative functor
effectful function
iteration
left scan
scan
tail recursion
richard bird
graham hutton
foldable
fp in scala
scalaz
join
fish operator
effectful
filter
combinatorial-puzzle
n-queens
graphics
streams
recursive datatype
recursive function
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
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
lists
natural numbers
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
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
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
mathematical definition
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