Blog

Post Index

Bluetape4k Exposed Part 6: BigQuery, Trino, CockroachDB, and DuckDB Integrations Before running against special-purpose databases, check the contracts that make the integration safe.

Operating an OCR Service in Practice: Large Image Preprocessing and Failure Response Contracts Treat an OCR service as a large-image input boundary, native OCR runtime boundary, and failure response contract, not just a text extraction endpoint.

Bucket4j Rate Limiting: Choose the Caller Identity Before the Bucket A practical look at Bucket4j rate limiting as caller identity, proxy trust, bucket storage, and response-header contracts.

bluetape4k Flow Extensions: Turning Stream Plumbing into Named Operational Contracts Six workshop examples showing how Kotlin Flow extensions make debounce, fallback, callback bridge, aggregation, parallel enrichment, and sampling contracts explicit.

Coroutine Observability: The Boundaries Micrometer Tracing and Readiness Actually Prove A workshop walkthrough of keeping traces connected across coroutine boundaries and treating readiness as a real operational contract.

Transactional Outbox Part 2: Kafka-First Fallback to Keep the Hot Transaction Small A Kafka-first outbox variant that writes durable fallback rows only when direct Kafka publish fails.

Transactional Outbox and Idempotency in Spring and Ktor Examples Use Spring and Ktor examples to see how domain rows, outbox rows, duplicate requests, and retries stay inside explicit failure boundaries.

Bluetape4k Text Part 4: Dictionary Updates and Quality Gates A one-line dictionary change can change tokenizer and blockword-filter behavior. This post shows how to clean, test, and document dictionary updates.

Bluetape4k Text Part 3: Aho-Corasick Search and Workshop Scenarios As keyword dictionaries grow, repeated contains checks become expensive and harder to reason about. Build the automaton once, then scan each input once.

Bluetape4k Text Part 2: Routing Input with Tokenizers and Language Detection Korean, Japanese, and fallback text paths should not be pushed through one generic string function. This post shows where the bluetape4k-text tokenizer and Lingua boundaries fit.

Bluetape4k Text Part 1: Starting Point and Quality Baseline Text processing becomes a service-boundary problem once user input, multilingual content, dictionaries, and safety checks meet.

Migrating Workshop Spring Modules to Jackson 3 on Spring Boot 4 Spring Boot 4 examples should follow the Jackson 3 line. Check dependencies, imports, mapper beans, and exceptions.

Rebuilding Batch Benchmarks: Moving from measureTimeMillis to kotlinx-benchmark Numbers are easy to produce. The harder part is deciding whether they are safe to believe.

Exposed R2DBC Workshop: Ktor Multi-Tenant Routing Patterns In Ktor, keep tenant state out of ThreadLocal. Resolve it once, store it on the call, and pass explicit routing values.

Bluetape4k Graph Part 5: Reading the Virtual Threads Benchmark Virtual Threads are not faster graph calls. They are a simpler way to handle many graph calls that wait.

Global Unique ID Generator Performance: Go and Kotlin Go ID generator implementation, Phase 1 comparison, Go entropy improvements, Phase 2 comparison, Kotlin ULID/KSUID/Snowflake improvements, and Phase 3 comparison.

Bluetape4k Graph Part 4: Workshop Scenarios and Service Integration Runnable examples are the cheapest way to validate a graph design.

Bluetape4k Graph Part 3: Graph I/O and Benchmarks Graph data must be exportable, importable, and reproducible in tests.

Bluetape4k Graph Part 2: Core API and Execution Models The core API reduces repeated service code without pretending every graph storage behaves the same.

Bluetape4k Graph Part 1: Database Selection Map After deciding to use a graph database, the next question is which graph storage to start with.

Bluetape4k JaVers Part 3: DDD and Workshop Audit Example Move from manual audit tables to JaVers snapshots, DDD repositories, and Kafka/Redis projection flow.

Bluetape4k JaVers Part 2: Exposed, Redis, and Kafka Persistence Exposed is durable history, Redis is fast snapshot reads, and Kafka is a write-only event stream.

Bluetape4k JaVers Part 1: Audit and Diff Overview Start with the JaVers commit, snapshot, and diff model before creating another audit table per entity.

Bluetape4k AWS Part 5: Applying the Real Examples A practical tour of examples/ and bluetape4k-workshop/aws for Spring Boot, Ktor, S3, SQS, and DynamoDB.

Bluetape4k AWS Part 4: Comparing with Spring Cloud AWS A comparison of Spring Cloud AWS and bluetape4k-aws by ownership boundary rather than feature count.

Bluetape4k AWS Part 3: Spring Boot and Ktor Integration How Spring Boot 4 auto-configuration and Ktor 3 plugins sit on the same AWS helper layer.

Bluetape4k AWS Part 2: Core Modules and Service Coverage Java SDK v2 approach, Kotlin SDK approach, CRT-backed S3 TransferManager, and the compileOnly dependency model.

Bluetape4k AWS Part 1: Repository Overview and Mental Model The mental model for AWS SDK wrappers, coroutine helpers, Spring Boot 4, Ktor 3, and LocalStack/Floci tests.

Bluetape4k Leader Part 5: Backends, Operations, and Benchmarks Choose the leader election backend by the systems you already operate, lease storage, observability, and API fit.

Bluetape4k Leader Part 4: Spring Boot and Ktor Integration Moving direct runIfLeader calls into Spring AOP and Ktor scheduler/management boundaries.

Bluetape4k Leader Part 3: Multi-leader and Strategic Election When one leader is too few: group slots and candidate strategies for controlled execution.

Bluetape4k Leader Part 2: Core APIs and Execution Models Four execution models for one job: blocking, CompletableFuture, coroutine, and virtual thread.

Bluetape4k Leader Part 1: Repository Overview and Mental Model How scheduled jobs, migrations, pollers, and cache warmers avoid running on every replica.

Bluetape4k Exposed Part 5: Production Examples with Cache and Multi-Tenancy Add performance and production behavior on top of Exposed repositories and transaction boundaries.

Bluetape4k Exposed Part 4: JSON, Encryption, and Dialects Keep database-specific details out of domain code by isolating them in typed columns and dialect modules.

Bluetape4k Exposed Part 3: R2DBC, Coroutines, and Virtual Threads R2DBC fits streaming. JDBC with Virtual Threads keeps the familiar driver path. Choose with numbers.

Bluetape4k Exposed Part 2: JDBC Repositories and SQL DSL Do not hide SQL DSL; remove only the repeated repository boundary code.

Bluetape4k Exposed Part 1: Why Exposed? Choosing a production Exposed extension path after R2DBC, Vert.x, Virtual Threads, and Exposed DSL.

Bluetape4k Projects Part 6: Spring Boot 4 and Ktor How Spring Boot 4 and Ktor 3 shape coroutine, data, Redis, observability, and testing boundaries.

Bluetape4k Projects Part 5: utilities and adoption path Choose small utility modules only when needed, then validate the path with examples and benchmark notes.

Bluetape4k Projects Part 4: data and infrastructure A practical map for DB, Redis, messaging, observability, and resilience boundaries in Kotlin services.

Bluetape4k Projects Part 3: the path bytes take I/O boundaries where files, buffers, serializers, HTTP/RPC clients, and encryption meet.

Bluetape4k Projects Part 2: Core, Coroutines, Logging, Tests The core, coroutine, logging, and testing foundation shared by service requests and test fixtures.

Bluetape4k Projects Part 1: The Shared Kotlin/JVM Foundation Why core, coroutines, I/O, data, infra, Spring Boot, Ktor, testing, and the BOM live together.

Bluetape4k Cache Part 4: Getting a Feel for Cache Strategies with Workshop Examples Comparing Caffeine, Redis, Near Cache, and resilience through working examples.

Bluetape4k Cache Part 3: Building Caching Strategies with Near Cache and Exposed Read-through, write-through, and write-behind sound similar. Their tradeoffs are not.

Bluetape4k Cache Part 2: Near Cache as a Practical Way to Reduce Redis Round Trips A remote cache is shared, but far away. Near Cache keeps hot reads close to the JVM.

Bluetape4k Cache Part 1: Why the Cache Module Looks This Way Why local caches, JCache, suspend APIs, memoizers, and NearCache live in the same toolbox.

Virtual Threads Part 4: Hiding Java 21 and Java 25 Behind One API Hide Java 21/25 differences inside runtime providers and keep application code on one Virtual Threads API.

Virtual Threads Part 3: Why JDBC Beat R2DBC More Often Than Expected R2DBC looked like the obvious winner, but the benchmark results disagreed. A practical look at JDBC + Virtual Threads.

Virtual Threads Part 2: Rules That Matter in Practice Turning on Virtual Threads is not the finish line. Pooling, semaphores, context, and locks decide whether they work well.

Virtual Threads Part 1: Cheap Threads, Not Magic Threads Blocking code gets a second life, but only when timeout, cleanup, and resource limits come along with it.

Embarrassing Bugs That Made Better Guards A candid write-up of five bluetape4k-projects fixes: null becoming zero, stale tests, cleanup timeouts, swallowed cancellation, and lost interrupt status.

When Ktor CIO Made HTTP Benchmarks Weird How slow Ktor CIO numbers led to a fairer benchmark, a Vert.x pool fix, and workload-based HTTP client guidance.

When the CSV Writer Took Off Its Ankle Weights The Okio CSV writer follow-up: Flow rows, UTF-8 sinks, behavior locks, and a 3.25x large export win.

Reducing CSV Parser Allocations with Okio Segments A benchmark-backed account of the CSV parser optimization, from Reader parsing to Okio UnsafeCursor segment scanning.

From Pure JVM to libvips: Benchmarking Image Processing in bluetape4k Benchmark results for scrimage vs libvips, Java 21 JNI host limits, Java 25 FFM measurements, and a workshop derivative pipeline example.

When Should a Backend Service Adopt a Graph Database? Benchmark-backed notes on GraphDB adoption criteria, PostgreSQL traversal baselines, AGE, Neo4j, Memgraph, and the use cases where graph storage is worth the cost.

Bluetape4k Ecosystem at a Glance A layer-by-layer map of Bluetape4k across Spring Boot 4, Ktor 3, domain capabilities, data, infrastructure, and foundation modules.

Turning AI Collaboration Into Infrastructure How AGENTS.md, bluetape4k skills, qmd, memory, and hooks help Codex and Claude read and verify work against the same standards.

Growing a Large Kotlin Library Ecosystem with AI in Three Months How Claude Code and Codex helped with automation, documentation, tests, research, examples, cross-repository consistency, and workflow discipline.