bluetape4k-dependencies 2.0.0 in Practice Part 4: Operational Diagnostics and Fail-Closed Boundaries Keep unobservable state distinct from healthy state, and stop safely at corrupted history or unbounded input.
Blog
Post Index
Section titled “Post Index” 121 posts
Popular tags All Kotlin 89 Practical Example 45 Architecture 40 Resilience 38 Timefold 31 Appointment Service 30 Example 30 Spring 29 Exposed 25 Persistence 22 Performance 17 Dependencies 16
All tags
AI 5 Appointment Service 30 Architecture 40 AWS 9 Barcode 1 Billing 4 BOM 5 Cache 9 Comparison 13 Concurrency 12 Coroutines 13 DATA Isolation 1 DDD 1 Dependencies 16 Diagnostics 1 Domain Modeling 12 Ecosystem 11 Event Driven 15 Example 30 Exposed 25 FAIL Closed 1 Fulfillment 1 Golang 1 Graph 8 Idempotency 3 Image 11 JAVA 1 JaVers 8 JDBC 6 Kafka 5 Kotlin 89 Ktor 14 Leader Election 10 Messaging 8 Microservices 2 Migration 5 Mobile 1 Moderation 1 Multi-Tenancy 5 NATS 1 Notification 2 Observability 8 OCR 2 Operations 13 Optimization 6 Outbox 4 Patient Portal 1 Performance 17 Persistence 22 PostgreSQL 7 Practical Example 45 R2DBC 7 Redis 9 Release Train 2 Reliability 2 Reminder 1 Resilience 38 Search 7 Security 3 Spring 29 Statistics 1 Testing 11 Text 10 Timefold 31 Transactions 5 Virtual Threads 9
bluetape4k-dependencies 2.0.0 in Practice Part 3: Ownership in Messaging and Streams Put acknowledgement and checkpoint boundaries between message receipt and completed business work.
bluetape4k-dependencies 2.0.0 in Practice Part 2: Data Access and Processing Lifecycles From tenant selection to the committed chunk checkpoint, separate each data-processing owner and lifecycle.
bluetape4k-dependencies 2.0.0 in Practice Part 1: Java 25 and Compatibility Boundaries Before changing one BOM line, inspect the JVM, package, annotation-processing, configuration, and container-image boundaries.
[Operations 11 · Appendix] How Patient Portals and Mobile Channels Show an Appointment A patient portal view of appointments, notifications, and profile; appointment actions protected by ETags and idempotency keys; SSE with polling fallback; and the still-open mobile roadmap.
[Operations 10] Apply Only the Latest Calculation to an Appointment Compare the source version at calculation time with the version at apply time, then make policy and notification retries observable to STAFF.
[Operations 9] Retries and Replay Must Change an Appointment Only Once Connect the HTTP idempotency key, outbox, inbox, quarantine, and STAFF action queue so retries never apply the same appointment change twice.
[Operations 8] Data Boundaries for Running Multiple Clinics in One Appointment Service A practical boundary for carrying tenant and clinic scope from the request path through queries, caches, and events, while helping STAFF decide the next action.
[Operations 7] How Appointment Results Reach External Systems and Statistics How the outbox, consumer inbox, statistics projection, current appointment aggregate, and STAFF action queue keep their responsibilities separate.
[Operations 6] Why Notifications and Reminders Are Separate Services Why appointment confirmation and notification delivery stay separate, and how STAFF sees the next action when a reminder is missing.
[Operations 5] Attendance and Treatment Completion Are Different Facts A STAFF operations view and state/event flow for keeping attendance, appointment completion, and actual treatment fulfillment separate.
[Operations 4] Profile Changes Do Not Rewrite Confirmed Visit Commitments A STAFF-centered view of profile reevaluation: use CRM changes as a reason to review reservations, while protecting PROPOSED, HELD, and CONFIRMED state boundaries.
[Operations 3] Appointment Recovery Starts with Impact Discovery A practical guide to incident scope, candidate calculation, version rechecks, STAFF confirmation, and follow-up work when clinic disruptions force appointment changes.
[Implementation 9] Freezing Package Choices and Execution Order into a Visit Plan See how package choices, exact component versions, execution order, visit grouping, event ordering, and atomic persistence are validated before a visit-plan revision is appended.
[Implementation 8] Expanding an N-Visit Purchase into a Visit Plan How repeated purchase rights become visit-plan occurrences, with completion, refund, and interval boundaries preserved as revision history.
[Design 7] Why Every Clinic Has Different Booking Rules How policy inheritance, overrides, versions, and activation boundaries explain clinic-specific booking results.
[Operations 1.3] A Waitlist Operations Command Is Complete Only After the API Request and Re-read Connects the confirm and decline buttons on an operations screen to scope, version, idempotency, and re-read contracts.
[Operations 1.2] A Waitlist Dashboard Should Tell Staff What to Do Next Connect waitlist state to clinic metrics, an action queue, evidence, and permitted commands instead of stopping at a list of rows.
[Operations 1.1] A Waitlist Is Not a Queue of Names Model a waitlist as a state machine that offers, holds, claims, and recovers one vacant slot at a time.
[Operations 2] Who Owns Booking Priority? A policy and domain model for applying no-show history and VIP priority signals while preserving policy ownership and confirmed appointments.
[Design 6] A Preferred Visit Date Is Not an Appointment Confirmation Separate scheduling intent from appointment confirmation, and protect an existing appointment when PROPOSED, HELD, and CONFIRMED states or consent-bound changes are processed.
[Design 5] How a Product BOM Becomes an AppointmentPlan and a Visit A business-first explanation of the two translations from a package purchase to an appointment plan and a real visit.
[Design 4] Why a Package Product Becomes an Execution Graph Explain how package components, choice rules, and predecessor relationships become real appointment items across one or more visits.
[Design 3] Why an N-Visit Product Is Not One Appointment Why a multi-visit purchase keeps its remaining rights separate from the appointments that are confirmed one at a time.
[Design 2] What Visit Commitment Does an Event Product Create? Follow how an event product purchase becomes a confirmed visit only after candidate calculation and customer consent.
[Design 1] When a Product Changes, Preserve the Patient's Promise: Product Versions and Purchase Snapshots A patient-centered explanation of purchase snapshots and Plan revisions when a product changes.
[Prologue] From Product Information to a Patient's Visit Commitment Map how event, multi-visit, and package products become visit commitments and objective attendance and counseling facts.
A Barcode and QR Contract Unlike OCR: Preserve Values, Formats, and Regions Preserve barcode and QR values, formats, and optional regions in a provider-neutral contract separate from OCR and policy.
Separate Detection Facts from Processing Policy: The Boundary Between Facts, Actions, and Review Keep detector facts separate from visitor-pass policy so false positives, false negatives, and manual-review boundaries remain explicit.
Connect OCR Results to the Combined Response: Distinguishing Empty, Unavailable, and Failed Distinguish an empty OCR result, an unavailable provider, a timeout, and a provider failure without losing detection or barcode results.
Usage Billing Part 4: Detection, Isolation, Reprocessing, and Reconciliation Turn detection, incident scoping, failure classification, isolation, reprocessing, and reconciliation into one evidence-based billing recovery runbook.
Usage Billing Part 3: Microservices, Outbox, and Inbox Follow service-owned data, local transactions with Outbox, Inbox decisions, version gaps, and poison-event recovery through one billing flow.
Usage Billing Part 2: Event Sourcing, Replay, and Projection Operations See how replay, schema evolution, projection generations, and failure isolation change when the Event Store becomes billing authority.
Usage Billing Part 1: Duplicate Ingestion, Resumable Closing, and the Ledger See how one PostgreSQL authority handles duplicate usage, changing prices, resumable closing, and late adjustments.
Qualify Before You Analyze: Shared Input Guards and a Single Decode See how multiple image analyzers share input qualification, compressed-size and pixel budgets, actual file-format checks, and one full decode.
Extracting Multiple Signals from One Image: Boundaries for OCR, Object Detection, and QR Processing See how an API reads text, object regions, and QR values from one image, preserves partial failures, and passes analysis facts into business policy.
Spring WebFlux Multi-tenancy: From Reactor Context Propagation to Tenant Onboarding Carry tenant identity safely into coroutines and DB selection, and use one operational contract for authorization, durable lifecycle state, and new-tenant onboarding.
Event Delivery Inside One Application: Choosing Between Spring Modulith Publications and an Outbox Separate local listener recovery inside one application from event delivery across an external boundary.
Bluetape4k JaVers Part 4: Audit Logs Are Not Free Use committed benchmark evidence to choose audit scope, snapshot storage, and commit metadata indexes.
[Implementation 7] Reviews and Operations Start the Next Development Cycle Turn review findings and operational evidence into the next requirement, regression test, and durable design decision.
Timefold Server in Practice: From Planning Models to the Exposed Persistence Boundary Bed allocation and school timetabling use the same Timefold APIs but model different planning variables and score levels. See what an application must add around Solver execution for durable jobs, approval, and business updates.
[Implementation 6] Rescheduling after Closures and Equipment Downtime Connect clinic closures and equipment downtime to pending state, candidate generation, approval, audit history, and notification boundaries.
How to Keep Multiple Servers from Running the Same Job Keep tenant jobs parallel while guarding migrations globally. These examples define leader-election scope and failure boundaries from the work itself.
Keeping Reservation Capacity Correct Under Concurrent Requests Concurrent requests, retries, hold expiry, waitlists, and Redis outages still need one durable authority for reservation capacity.
[Implementation 5] Translating Clinic Rules into Timefold Constraints Translate clinic policy into 12 hard Constraint Streams, 6 soft goals, and an explainable HardSoftScore.
[Implementation 4] Real-Time Slot Search and Global Optimization Solve Different Problems See why listing valid slots for one request and optimizing a clinic-wide schedule need separate services.
[Implementation 3] Computing Availability from Clinic-Specific Hours and Resources Intersect clinic and doctor calendars, then apply downtime and resource constraints to produce genuinely bookable slots.
[Implementation 2] Appointment State Is More Than an Enum Connect allowed transitions, reasons, and history instead of storing only the current appointment state.
[Implementation 1] Clinic Appointments Are More Than CRUD Follow one appointment from requirements to module boundaries and uncover the clinic rules behind it.
Bluetape Skills Part 3: Recovering and Resuming Interrupted Workflows How the 1.1.0 runtime identifies interrupted lanes and recovers workflows from receipts and component evidence.
Bluetape Skills Part 2: Starting Work with bluetape-workflow How bluetape-workflow routes a request through classification, plan approval, leaf skills, step evidence, and final DoD.
Bluetape Skills Part 1: Sharing and Installing the Toolkit How canonical skills, bundled references, install validation, and a private-runtime boundary make Bluetape Skills portable.
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 Spring Boot 4 Workshop Examples to Jackson 3 Align dependencies, code APIs, configuration, and verification in Spring Boot 4 examples with the Jackson 3 baseline.
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.
Building bluetape4k-dependencies Part 3: Maven Central Has No Rollback Button A multi-repository release train looks operational, and careless release order turns into very concrete cleanup work.
Building bluetape4k-dependencies Part 2: Making the 1.0.0 BOM a Public Contract A BOM is not a version table. It is a public contract that changes dependency resolution in user projects.
Building bluetape4k-dependencies Part 1: Why the BOM Became Necessary One library can live with one version. When several repositories move together, a BOM becomes an operating contract.
bluetape4k-dependencies 1.3.0 in Practice Part 4: Input Boundaries and Resource Safety Input boundaries often pass small samples and fail on production data. Image and Text changes are easiest to understand from the API edge.
bluetape4k-dependencies 1.3.0 in Practice Part 3: Production Signals The dangerous production problem is the one that looks quiet too long. 1.3.0 exposes more of the signal.
bluetape4k-dependencies 1.3.0 in Practice Part 2: Selecting Modules by Service Boundary After importing the BOM, the next question is which modules belong together at each service boundary.
Using bluetape4k-dependencies: Combining Multiple Libraries When several bluetape4k libraries are used together, import the BOM first instead of memorizing every module version.
bluetape4k-dependencies 1.3.0 in Practice Part 1: Features and Cleanup The version number is less interesting than which library boundaries became clearer and which old mistakes were removed.
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 Benchmark Interpretation 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: Graph Database Selection Criteria After deciding to use a graph database, choose a store that fits the workload and operating environment.
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 Exploring Caffeine, Redis, resilience, and Exposed loader/writer strategies 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.
No posts match the selected tag.