Programs as Values - Write code and don't get lost

PROGRAMS AS
VALUES
WRITE CODE AND DON'T GET LOST
1 — Pierangelo Cecchetto - LambdaConf 2025

THE CODE ARCHEOLOGIST
PROBLEM
▸ "Investigation requests" (not "Bug Reports")
▸ What is the system doing?
▸ What is the system supposed to do?

INVESTIGATION REQUEST
#1
System consumes documents from Kafka and
produces processing proofs. We see 100
messages going in, and only 70 are OK.
Why did 30 go to DLQ?

#2
In a purchase approval system, I see 30
transactions refused out of 100. Why are they
refused?

#3
"We were supposed to see 8 shop locations on
Google Maps but we see only 6. Why is that?"

AND TO MAKE THINGS
MORE INTERESTING...
▸ No error messages in our logs

THE PROMISE OF FP
FOCUS ON THE WHAT RATHER THAN THE HOW
// HOW (Procedural)
val x = List(1, 2, 3)
val y = scala.collection.mutable.ArrayBuffer.empty[Int]
for (i <- 0 until x.size) {
y += x(i) * 2
}
// WHAT (Functional)
val x = List(1, 2, 3)
val y = x.map(_ * 2)

THE PROMISE OF FP
IN BUSINESS LOGIC PROBLEMS - HEALTH CHECK
/**
* Check db connectivity
*/
def checkErrors(): ZIO[Transactor[Task] & AdminClient & SttpClient, Nothing, List[StatusError]] = {
def dbCheck(
dbType: DbType,
checkTables: List[TableName]
): ZIO[Transactor[Task], Nothing, List[StatusError]] =
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
): URIO[AdminClient, Option[StatusError]] =
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
): URIO[SttpClient, List[StatusError]] =
/*
* Sttp code
*/
ZIO
.collectAll(
List(
dbCheck(
DbType.MySql,
List(TableName("table1"), TableName("table2"))
),
kafkaCheck(List(Topic("topic1"), Topic("topic2"))),
httpCheck(Url("http://localhost:8080"))
)
)
.map(_.flatten)
}

THE PROMISE OF FP
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/

THE PROMISE OF FP
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
/*
* Sttp code
*/
ZIO
.collectAll(
List(
dbCheck(DbType.MySql, List(TableName("table1"), TableName("table2"))),
)
)
.map(_.flatten)
}

THE PROMISE OF FP
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/

THE PROMISE OF FP
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
/*
* Sttp code
*/
ZIO
.collectAll(
List(
)
)
.map(_.flatten)
}

THE PROMISE OF FP
def httpCheck(
url: Url
/*
* Sttp code
*/
}

THE PROMISE OF FP
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
/*
* Sttp code
*/
ZIO
.collectAll(
List(
)
)
.map(_.flatten)
}

THE PROMISE OF FP
ZIO
.collectAll(
List(
)
)
.map(_.flatten)

PURELY FUNCTIONAL CODE
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
/*
* Sttp code
*/
ZIO
.collectAll(
List(
)
)
.map(_.flatten)
}
▸ Immutable values
▸ Strongly typed - neotype
▸ Functional effect system -
ZIO

PURELY FUNCTIONAL CODE
def dbCheck(
dbType: DbType,
/*
* Doobie code
*/
def kafkaCheck(
topics: List[Topic]
/*
* ZIO-kafka code
*/
def httpCheck(
url: Url
/*
* Sttp code
*/
ZIO
.collectAll(
List(
)
)
.map(_.flatten)
}
Is it focused on the how or on the
what?

PROBLEM #1: ARBITRARY FUNCTIONS
def checkErrors(): ZIO[Transactor[Task] & AdminClient & SttpClient, Nothing, List[StatusError]] =
ZIO.collectAll(
List(
httpCheck(Url("http://localhost:8080")),
ZIO.succeed(List(StatusError("Fourth error")))
ZIO.die(new RuntimeException("Error in the fifth check"))
)
)
.map(_.flatten)

PROBLEM #2: DIVERGENT DOCUMENTATION
/**
*/
def checkErrors() =
dbCheck(DbType.MySql, List(TableName("table1"), TableName("table2")))

PROBLEM #2: DIVERGENT DOCUMENTATION
/**
*/
def checkErrors() = ZIO
.collectAll(
List(
)
)
.map(_.flatten)

PROBLEM #3: SOLUTION BOUND TO ZIO
▸ Legacy services use Future and Slick
▸ No guarantee of equivalence between implementations

ORTHOGONALITY
ADDRESS ALL THREE PROBLEMS INDEPENDENTLY:
1. Constrain what we can do
2. Keep documentation always aligned with code
3. Make solution stack-agnostic

DEFINE A LANGUAGE TO DESCRIBE OUR
SOLUTION

MODEL THE SOLUTION
sealed trait ErrorCondition
object ErrorCondition {
case class DBErrorCondition(dbType: DbType, checkTables: List[TableName]) extends ErrorCondition
case class KafkaErrorCondition(topics: List[Topic]) extends ErrorCondition
case class HttpErrorCondition(url: Url) extends ErrorCondition
}

ADD COMBINATORS
object ErrorCondition {
case class Or(left: ErrorCondition, right: ErrorCondition) extends ErrorCondition
case class DBErrorCondition(dbType: DbType, checkTables: List[TableName]) extends ErrorCondition
case class KafkaErrorCondition(topics: List[Topic]) extends ErrorCondition
case class HttpErrorCondition(url: Url) extends ErrorCondition
}

DESCRIBE SOLUTIONS THROUGH DATA
STRUCTURES
Or(
DBErrorCondition(
DbType.Postgres,
List(TableName("user"), TableName("access_token"))
),
HttpErrorCondition(
Url("https://license-check.org/check")
)
)

MAKE IT ERGONOMIC
sealed trait ErrorCondition { self =>
def ||(other: ErrorCondition): ErrorCondition = Or(self, other)
}
object Dsl:
def dbErrorCondition(dbType: DbType, checkTables: TableName*): ErrorCondition =
DBErrorCondition(dbType, checkTables.toList)
def kafkaErrorCondition(topics: Topic*): ErrorCondition =
KafkaErrorCondition(topics.toList)
def getHttp2xx(url: Url): ErrorCondition =
HttpErrorCondition(url)

MAKE IT ERGONOMIC
val errorCondition =
dbErrorCondition(DbType.Postgres,
TableName("user"), TableName("access_token")
) ||
getHttp2xx(Url("https://license-check.org"))

FLEXIBILITY
) ||
getHttp2xx(Url("https://license-check.org")) ||
kafkaErrorCondition("messages-topic")

FLEXIBILITY
) ||
getHttp2xx(Url("https://license-check.org")) ||
kafkaErrorCondition("messages-topic") ||
dbErrorCondition(dbType, TableName("documents"))

ORTHOGONALITY
1.
✅
Constrain what we can do
2.
⬜
Keep documentation always aligned with code
3.
⬜
Make solution stack-agnostic

RUN IT: MAKE A CHECKERRORS()
Compile the data structure into a function
object ZIOInterpreter {
def checkErrors(errorCondition: ErrorCondition): ZIO[Transactor[Task] & AdminClient & SttpClient, Nothing, List[StatusError]] =
errorCondition match
case ErrorCondition.DBErrorCondition(DbType.Postgres, checkTables) =>
DoobieZIOdBHealthcheck.status(DoobieZIOdBHealthcheck.existsPostgres, checkTables)
case ErrorCondition.DBErrorCondition(DbType.MySql, checkTables) =>
DoobieZIOdBHealthcheck.status(DoobieZIOdBHealthcheck.existsMySql, checkTables)
case ErrorCondition.HttpErrorCondition(url) =>
SttpHealthCheck.check(url)
case ErrorCondition.Or(left, right) =>
interpret(left).zipPar(interpret(right)).map {
case (leftErrors, rightErrors) => leftErrors ++ rightErrors
}
}

INTERPRETER: THE BARE
MINIMUM
def checkErrors(ec: ErrorCondition): UIO[List[Errors]] =
ec match {
//cover all cases
}

INTERPRETER: OPTIMIZE
BEFORE RUNNING
private def optimize(ec: ErrorCondition): ErrorCondition =
/*
* collect all checks of the same type, to minimize the calls
*/
def checkErrors(ec: ErrorCondition): UIO[List[Errors]] =
optimize(ec) match {
//cover all cases
}

BENEFITS: TECH STACK INDEPENDENCE
For a Future/Slick implementation:
def checkErrors(
db: slick.jdbc.JdbcBackend#Database,
jdbcProfile: slick.jdbc.JdbcProfile,
httpClient: SttpFutureBackend[Future, Any]
)(
errorCondition: ErrorCondition )(implicit ec: ExecutionContext): Future[List[StatusError]] =
errorCondition match {
// Different implementation, same logic
}

BENEFITS: DOCUMENTATION FROM CODE
def interpret(errorCondition: ErrorCondition): String =
//render (statefully) all cases
}
_

BENEFITS: DOCUMENTATION FROM CODE
def interpret(errorCondition: ErrorCondition): String =
//render (statefully) all cases
}
Output:
Either of:
Database Check (Postgres):
Required tables: customer, access_token
OR
Kafka Check:
Required topics: events
OR
HTTP Check:
URL: http://localhost:8080/status/200
are detected for failure

ORTHOGONALITY
1.
✅
Constrain what we can do
2.
✅
Keep documentation always aligned with code
3.
✅
Make solution stack-agnostic

EVOLUTION OF THE LANGUAGE
New requirement New term in the algebra
case class RabbitMQErrorCondition(exchanges: List[Exchange]) extends ErrorCondition
def rabbitMQErrorCondition(exchanges: Exchange*): ErrorCondition =
RabbitMQErrorCondition(exchanges.toList)

A MORE COMPLEX EXAMPLE
PAYMENT AUTHORIZATION RULES
The problem: Authorizing payments based on complex evolving rules
def isBlocked(creditCard: CreditCard, purchase: Purchase): Boolean

DOMAIN MODEL
case class CreditCard(
id: Id,
cardNumber: CardNumber,
cardHolderName: CardHolderName,
cardType: CardType,
expiryDate: ExpiryDate,
issuedInCountry: Country
)
case class Purchase(
id: Id,
creditCardId: Id,
amount: Amount,
shopId: ShopId
)
case class Shop(
id: ShopId,
name: ShopName,
country: Country,
categories: List[ShopCategory]
)

PAYMENT APPROVAL SYSTEM
def isBlocked(creditCard: CreditCard, purchase: Purchase): Boolean

FIRST REQUIREMENT
"Block all electronic purchases in China"
Naive implementation:
def isBlocked(creditCard: CreditCard, purchase: Purchase): Boolean =
purchase.shop.country == Country.China &&
purchase.shop.categories.contains(ShopCategory.Electronics))

BUILDING THE BASIC RULES
sealed trait BlockingRule
case class PurchaseOccursInCountry(country: Country) extends BlockingRule
case class PurchaseCategoryEquals(purchaseCategory: ShopCategory) extends BlockingRule
case class PurchaseAmountExceeds(amount: Double) extends BlockingRule
case class FraudProbabilityExceeds(threshold: Probability) extends BlockingRule
case class CreditCardFlagged() extends BlockingRule
case class ShopIsBlacklisted() extends BlockingRule

ADDING COMBINATORS
sealed trait BlockingRule { self =>
def &&(other: BlockingRule): BlockingRule = BlockingRule.And(self, other)
def ||(other: BlockingRule): BlockingRule = BlockingRule.Or(self, other)
}

USER-FRIENDLY CONSTRUCTORS
object DSL {
private def purchaseInCountry(country: Country): BlockingRule =
BlockingRule.PurchaseOccursInCountry(country)
def purchaseCountryIsOneOf(countries: Country*): BlockingRule =
countries.map(purchaseInCountry).reduce(_ || _)
private def purchaseCategoryEquals(purchaseCategory: ShopCategory): BlockingRule =
BlockingRule.PurchaseCategoryEquals(purchaseCategory)
def purchaseCategoryIsOneOf(purchaseCategories: ShopCategory*): BlockingRule =
purchaseCategories.map(purchaseCategoryEquals).reduce(_ || _)
def purchaseAmountExceeds(amount: Double): BlockingRule = BlockingRule.PurchaseAmountExceeds(amount)
def fraudProbabilityExceeds(threshold: Probability): BlockingRule = BlockingRule.FraudProbabilityExceeds(threshold)
def creditCardFlagged: BlockingRule = BlockingRule.CreditCardFlagged()
def shopIsBlacklisted: BlockingRule = BlockingRule.ShopIsBlacklisted()
}

RULE INTERPRETER
def isBlocked(
ccFlaggedService: CreditCardFlaggedService,
fraudScoreService: FraudScoreService,
shopRepository: ShopRepository)(
rule: BlockingRule
)(cc: CreditCard, p: Purchase): UIO[Boolean] = {
def eval(rule: BlockingRule): UIO[Boolean] = rule match {
case BlockingRule.PurchaseOccursInCountry(country) =>
purchaseOccursInCountry(BlockingRule.PurchaseOccursInCountry(country))(input)
case BlockingRule.PurchaseCategoryEquals(purchaseCategory) =>
purchaseCategoryEquals(BlockingRule.PurchaseCategoryEquals(purchaseCategory))(cc, p)
case BlockingRule.PurchaseAmountExceeds(amount) =>
purchaseAmountExceeds(BlockingRule.PurchaseAmountExceeds(amount))(input)
case BlockingRule.CreditCardFlagged() => creditCardFlagged(ccFlaggedService)(cc, p)
case BlockingRule.FraudProbabilityExceeds(threshold) =>
fraudProbability(BlockingRule.FraudProbabilityExceeds(threshold), fraudScoreService)(cc, p)
case BlockingRule.And(l, r) => eval(l).zipWith(eval(r))(_ && _)
case BlockingRule.Or(l, r) => eval(l).zipWith(eval(r))(_ || _)
case BlockingRule.ShopIsBlacklisted() => shopRepository.isBlacklisted(p.shop.id)
}
eval(rule)
}

DOCUMENTATION FROM CODE: MERMAID
def toMermaidCode(blockingRule: BlockingRule): UIO[MermaidCode] = {
import MermaidInterpreter.Instances.given
for {
labelledTree <- label(blockingRule)
mermaidCode <- labelledToMermaidCode(labelledTree)
} yield MermaidCode(mermaidCode)
}

RULE EVOLUTION: V1
val br1 =
purchaseCountryIsOneOf(Country.China) &&
purchaseCategoryIsOneOf(ShopCategory.Electronics)

RULE EVOLUTION: V2
val br1 =
val br2 = br1 ||
(purchaseCountryIsOneOf(Country.UK) &&
purchaseCategoryIsOneOf(ShopCategory.Gambling))

RULE EVOLUTION: V3
val br1 =
val br2 = br1 ||
(purchaseCountryIsOneOf(Country.UK) &&
purchaseCategoryIsOneOf(ShopCategory.Gambling))
val br3 = br2 ||
(
purchaseCountryIsOneOf(Country.Italy) &&
purchaseCategoryIsOneOf(
ShopCategory.Gambling,
ShopCategory.Adult
) &&
purchaseAmountExceeds(1000) &&
fraudProbabilityExceeds(Probability(0.8))
)

BENEFITS
▸ Constrain the possibilities- Define a minimum set of things we can do, and
build from there
▸ Self-Documenting- Text/Visual representation directly from code
▸ Technology Independent- Same rules, different implementations
▸ Evolving Safely- Compiler catches missing cases
▸ Optimization- We can transform the rule tree before execution

...AND THERE IS MORE!
Not only algorithmic problems:
▸ ETL processing pipelines
▸ Workflows
▸ API requests (Tapir, ZIO-http)
▸ Domain-specific calculations

...AND THERE IS MORE!
Further developments:
▸ Serialize/Deserialize your business logic, version, revert
▸ Derive a visual debugger for complex logic

SCALA SHINES...
▸ Compiler exhaustive checks
▸ given & phantom types to make unwanted constructions
impossible

...BUT ALL YOU NEED IS DATA
▸ Languages with good ADT
▸ Pattern matching (data de-construction)
▸ Data types with methods for ergonomics

Keep it Simple
▸ No need for HKTs unless it is really necessary
▸ Restrict operations to a limited set
▸ We don't always need monads in high-level problems

Conservation
Principle
Clear
=
easy to understand, document, evolve

Conservation
Principle
Constraints Liberate, Liberties Constrain —
Runar Bjarnason

THANK YOU!
Questions?

Programs as Values - Write code and don't get lost

Recommended

More Related Content

Similar to Programs as Values - Write code and don't get lost (20)

Recently uploaded (20)

Programs as Values - Write code and don't get lost