- A Map of Akka
- A Simple Akka Cluster Application
- About Akka Streams
- Actor System Termination on JVM Shutdown
- Akka Actors to Akka Streams: When You Should Care
- Akka anti-patterns: being out of touch with the hardware
- Akka anti-patterns: flat actor hierarchies or mixing business logic and failure handling
- Akka anti-patterns: logging (the wrong way)
- Akka anti-patterns: too many actor systems
- Akka Best Practices: Defining Actor Props
- Akka event sourcing done right
- Akka notes - introducing actors
- Akka notes - actor messaging - 1
- Akka notes - logging and testing actors - 2
- Akka notes - actor messaging - request and response - 3
- Akka notes - actorsystem (configuration and scheduling) - 4
- Akka notes - actor lifecycle - basic - 5
- Akka notes - child actors and actorpath - 6
- Akka notes - deathwatch - 7
- Akka notes - actor supervision - 8
- Akka notes - finite state machines - 1
- Akka notes - finite state machines - 2
- Akka Persistence: Testing Persistent Actors
- Akka starter kit
- Akka Streams: A Motivating Example
- Akka Typed: First steps with typed actors in Scala
- Akka Typed Actors: Exploring the receiver pattern
- Akka Typed Actors: Exploring the receptionist pattern
- Building microservices with Scala and akka-http
- Clustering Akka in Kubernetes with Statefulset and Deployment
- Communicators: Actors with purely functional state
- CQRS and ES with Akka
- Demystifying Akka Extensions
- Extending RequestContext in akka-http for fun and profit
- Generic Rest API Services using Akka-Http
- Getting started with Kafka using Scala Kafka Client and Akka
- Handling Split Brain scenarios with Akka
- Integrating Akka Streams and Akka Actors: Part I
- My journey towards understanding distribution
- Patterns for Streaming Measurement Data with Akka Streams
- Performance Considerations for Akka Debug Logging
- Pokemon Go with Akka HTTP!
- Reactive DDD with Akka - integrating the Event Store
- Reactive DDD with Akka - lesson 2
- Reactive DDD with Akka - lesson 3 (Projections)
- Reactive DDD with Akka - putting the pieces together
- Reactive DDD with Akka
- Replacing akka actors with akka streams
- Scalability using Sharding from Akka Cluster
- Solving for High Throughput with Akka Streams
- Swagger for Akka HTTP
- Asynchronous Programming and Scala
- Calling Blocking Code: There Is No Free Lunch
- Tracing back scala future chains
- Fixing scala.collection.Iterator
- Making Sense Of Symbols In Scala's Collections API
- Scala Collection API for C# Developers
- Why scala.collection.Traversable Is Bad Design
- How to make the Scala compiler to review your code
- Scala clippy, helping you understand what the compiler errors actually mean
- Value Discarding
- 5 Things You Didn't Know About Synchronization in Java and Scala
- A Quick Guide to Concurrency in Scala
- Analyzing functions returning Future[T]
- Concurrency Models
- Futures and Thread pools
- Reactive Database Access – Part 1 – Why “Async”
- Reactive Database Access – Part 2 – Actors
- Reactive Database Access – Part 3 – Using jOOQ with Scala, Futures and Actors
- Scala notes - futures - 1
- Scala notes - futures - 2 (promises)
- Scala notes - futures - 3 (combinators and async)
- The worst thing in our Scala code: Futures
- Why you should know Monix
- API Design for Heaps (aka Priority Queues)
- Array based immutable collections
- Benchmarking Scala Collections
- Scala array comparison (without a PhD)
- Using RefTree for Visualizing Data Structures
- When Option Is Not Good Enough
- Why you can’t always flatMap to Option
- Working with scala collections
- Yet another iteratee library
- Dependency injection in play framework using scala
- EasyDI – Who wants some cake?
- Four ways to escape a cake
- Reader & Constructor-based Dependency Injection - friend or foe?
- Scrap Your Cake Pattern Boilerplate: Dependency Injection Using the Reader Monad
- Avoid Javaisms: Mocks, Stubs, DI is Code Smell
- Descriptive Variable Names: A Code Smell
- Design guidelines and justification
- Modelling Reactive Systems with Event Storming and Domain-Driven Design
- Old Design Patterns in Scala
- Scala as a configuration language
- Scala tips: Improving the imperfect part 1
- Scala tips: Improving the imperfect part 2
- Warts of the Scala Programming Language
- A New Strategy for Scala
- How Scala killed the Strategy Pattern
- Implicit Design Patterns in Scala
- Old Design Patterns in Scala
- Patterns in Scala: 101
- The High Cost of AnyVal subclasses...
- The Magnet Pattern
- Get Your Hands Dirty With Scala JVM Bytecode
- Performance of using default methods to compile Scala trait methods
- A useful F#-style |> operator for Scala
- C# yield return and Scala Continuations
- Methods as functions (or, what exactly is “eta expansion”?)
- On Currying and Partial Function Application
- Time Travel in Scala: CPS in Scala (scala’s continuation)
- A Beginner-Friendly Tour through Functional Programming in Scala
- A Modern Architecture for FP
- Exploring Currying and Partial Application using Scala
- FP for the average Joe - I - ScalaZ Validation
- FP for the average Joe - II - ScalaZ Monad Transformers
- FP for the average Joe - III - Applications as Coproducts of Free Algebras
- Functional Programmings concepts
- Introduction to Recursion Schemes with Matryoshka
- Lazy values
- Modern Functional Programming: Part 2
- More lazy values, the State monad and other stateful stuff
- Mutual tail recursion in Scala
- What's Functional Programming All About?
- Why? Here are some thoughts about typed functional programming in Scala
- Inferring implicit type parameters
- Revisiting implicits without import tax
- Understanding Implicits in Scala
- Allow Typeclasses to Declare Themselves Coherent
- Implicit function types
- Let by-name implicit parameters have lazy semantics
- Scala 2.13 collections rework
- 4 Fun and Useful Things to Know about Scala's apply() functions
- Ad hoc polymorphism in Scala for the mere mortals
- Equivalence versus Equality
- Evaluation strategies in Scala
- Refining your data from configuration to database
- Scala Enumerations - Return of the (Java) Jedi
- Scala Enumerations
- The myth of using Scala as a better Java
- Cheat Codes for Contravariance and Covariance
- Scala case classes
- Scala classes and objects
- Typesafe Domain Objects in Scala
- Making a REST API with Play
- Speeding up restful services in play framework
- Swagger with Play: All you need to know
- Upgrading from play framework 2.3 to play 2.5
- Work Stealing: What Makes the Play Framework Fast
- Akka.io, sbt-assembly and Docker
- Essential SBT (build tool for Scala)
- Improving your project with SBT
- Optimizing SBT resolution times
- Sbt heiroglyphs and multi-projects explained
- Yet another sbt-docker introduction
- Effective Programming In Scala – Part 1 : Standardizing code in better way
- Effective Programming In Scala – Part 2 : Monads as a way for abstract computations in Scala
- Effective Programming In Scala – Part 3 : Powering Up your code implicitly in Scala
- Enforcing invariants in Scala datatypes
- Overcoming immutability in Scala
- Scala Best Practices
- Scala Style Guide
- Strategic Scala Style: Conciseness & Names
- Strategic Scala Style: Designing Datatypes
- Strategic Scala Style: Practical Type Safety
- Strategic Scala Style: Principle of Least Power
- True scala complexity
- A Hands-On Introduction to ScalaTest
- Diamond Kata - TDD with only Property-Based Tests
- Getting the most out of ScalaCheck
- How to Add Integration Tests to a Play Framework Application Using Scala
- Sharing Tests and Generating Tests in Scala
- Unit Testing - Cassandra with Phantom
- What's new in ScalaTest 3
- Writing Acceptance Tests for Collections: Two Approaches
- Algebraic Data Types
- Choosing variance for a phantom type
- Existential types are not raw types
- Existential types in Scala
- Existential types
- Explaining Miles's Magic
- Generalized type constraints in Scala (without a PhD)
- Higher-kinded types: the difference between giving up, and moving forward
- Lazy Vals in Scala: A Look Under the Hood
- Overcoming type erasure in Scala
- Scala’s Types of Types
- The missing diamond of Scala variance
- The Scala Type System: Parameterized Types and Variances, Part 1
- The Scala Type System: Parameterized Types and Variances, Part 2
- The Scala Type System: Parameterized Types and Variances, Part 3
- The Unsound Playground
- The Unreasonable Effectiveness of Reasoning: Eliminating Bottom
- Type Families In Scala - Typed Sprintf
- Type Level Programming in Scala step by step
- Type Parameters and Type Members pt1: Type members are (almost) type parameters
- Type Parameters and Type Members pt2: When are two methods alike?
- Type Parameters and Type Members pt3: What happens when I forget a refinement?
- Type Parameters and Type Members pt4: Type projection isn't that specific
- Type Parameters and Type Members pt5: Nested existentials
- Type Parameters and Type Members pt6: Values never change types
- Type Parameters and Type Members pt7: To change types, change values
- Type Parameters and Type Members pt8: It’s existential on the inside
- Type Parameters and Type Members pt9: Making internal state functional
- Understand Scala's core typechecking rules
- Using generalized type constraints - How to remove code with Scala 2.8
- Variance in Java and Scala
- A Comonad of Graph Decompositions
- Ad-hoc polymorphism and type classes
- Arrows, Monads and Kleisli – part I
- Arrows, Monads and Kleisli – part II
- Beautiful folds in Scala
- Demystifying the Monad in Scala
- Deriving incomplete type class instances
- Free Monads Are Expendable
- Free Monads using FreeK
- Freedom and Forgetfulness
- From Monad Transformers To The Eff Monad
- Functors and Applicatives
- Handling failure using Xor and Validated data types
- Help! My Monads are Nesting!
- Monads are confusing. Let us help
- Monads in the category theory
- On Free Monads
- Overview of free monad in cats
- Practical Monads: Dealing with Futures of Options
- Scala Cats library for dummies — part 1
- Scala Cats library for dummies — part 2
- Scala Cats library for dummies — part 3
- Scala Cats library for dummies — part 4
- Scala Comonad Tutorial, Part 1
- Scala Comonad Tutorial, Part 2
- Scala typeclass explained: Implement a String.read function
- Scalaz features for everyday usage part 1: Typeclasses and Scala extensions
- Scalaz features for everyday usage part 2: Monad Transformers and the Reader Monad
- Scalaz features for everyday usage part 3: State Monad, Writer Monad and lenses
- Scalaz Monad Transformers
- Subtype type classes don't work
- The free monad and its cost
- The underrated applicative functor
- Type Class 101: Applicative
- Type Class 101: ApplicativeBuilder
- Type Class 101: Category and Monads
- Type Class 101: Foldable
- Type Class 101: Functor
- Type Class 101: Monoid
- Type Class 101: Semigroup
- Type classes and generic derivation
- TYPE CLASSES FOR THE JAVA ENGINEER
- Type classes in Scala
- Why Do Monads Matter?
- Wrapping Java-Style Methods With ApplicativeError And Cats