<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Gemini Kim</title><description>Notes from building, operating, and learning from software.</description><link>https://geminikim.com/</link><language>en-US</language><item><title>Reader and Writer Are Options, Not Architecture Rules</title><link>https://geminikim.com/articles/use-reader-writer-patterns-as-options-not-rules/</link><guid isPermaLink="true">https://geminikim.com/articles/use-reader-writer-patterns-as-options-not-rules/</guid><description>Choose Reader, Writer, and tool-layer boundaries from code size, domain distance, legacy constraints, and team conventions—not imitation.</description><pubDate>Sat, 28 Dec 2024 00:00:00 GMT</pubDate><category>architecture</category><category>layering</category><category>design-patterns</category></item><item><title>The Common Module Trap: Organize Code Around Concrete Capabilities</title><link>https://geminikim.com/articles/delay-common-modules-until-boundaries-are-clear/</link><guid isPermaLink="true">https://geminikim.com/articles/delay-common-modules-until-boundaries-are-clear/</guid><description>Delay common modules until ownership is clear, and organize logging, exceptions, and shared protocols around concrete capabilities instead.</description><pubDate>Sat, 21 Dec 2024 00:00:00 GMT</pubDate><category>modules</category><category>architecture</category><category>maintainability</category></item><item><title>Join the Team Before You Try to Change It</title><link>https://geminikim.com/articles/earn-trust-before-changing-a-new-team/</link><guid isPermaLink="true">https://geminikim.com/articles/earn-trust-before-changing-a-new-team/</guid><description>Adapt to a new engineering team through timely questions, visible progress, early review, and small evidence-based changes after trust is earned.</description><pubDate>Sun, 15 Dec 2024 00:00:00 GMT</pubDate><category>teamwork</category><category>communication</category><category>career</category></item><item><title>How to Break Up a Giant Service Class Without Guesswork</title><link>https://geminikim.com/articles/split-large-service-classes-by-responsibility/</link><guid isPermaLink="true">https://geminikim.com/articles/split-large-service-classes-by-responsibility/</guid><description>Split an oversized service by mapping concepts, tracing responsibilities, testing boundaries, and comparing concrete refactoring options.</description><pubDate>Sun, 08 Dec 2024 00:00:00 GMT</pubDate><category>refactoring</category><category>architecture</category><category>object-oriented-design</category></item><item><title>Keep Operational Tables Clean by Building a Separate Query Model</title><link>https://geminikim.com/articles/separate-query-models-from-operational-tables/</link><guid isPermaLink="true">https://geminikim.com/articles/separate-query-models-from-operational-tables/</guid><description>Design operational tables around business concepts, then serve complex history and admin searches from a separate query model.</description><pubDate>Sun, 01 Dec 2024 00:00:00 GMT</pubDate><category>database</category><category>architecture</category><category>query-models</category></item><item><title>Enums or Code Tables? Let the Rate of Change Decide</title><link>https://geminikim.com/articles/choose-enums-or-code-tables-by-change-rate/</link><guid isPermaLink="true">https://geminikim.com/articles/choose-enums-or-code-tables-by-change-rate/</guid><description>Use enums for stable values and focused tables for frequently changing ones without turning one common-code table into a dumping ground.</description><pubDate>Sun, 24 Nov 2024 00:00:00 GMT</pubDate><category>data-modeling</category><category>enums</category><category>databases</category></item><item><title>One Database, Separate Boundaries: Controlling Data Access by Domain</title><link>https://geminikim.com/articles/separate-data-access-by-domain-boundary/</link><guid isPermaLink="true">https://geminikim.com/articles/separate-data-access-by-domain-boundary/</guid><description>How separate entity and repository boundaries can protect core rules from integration code even when both areas share one database table.</description><pubDate>Mon, 18 Nov 2024 00:00:00 GMT</pubDate><category>architecture</category><category>data-access</category><category>domain-boundaries</category></item><item><title>Append, Don’t Overwrite: Designing Immutable Operational Data</title><link>https://geminikim.com/articles/design-immutable-records-with-append-only-data/</link><guid isPermaLink="true">https://geminikim.com/articles/design-immutable-records-with-append-only-data/</guid><description>An append-only repayment example that makes history and synchronization clearer, along with the storage and query costs it introduces.</description><pubDate>Mon, 11 Nov 2024 00:00:00 GMT</pubDate><category>data-modeling</category><category>databases</category><category>operations</category></item><item><title>What a Utility Bill Can Teach Us About Domain Modeling</title><link>https://geminikim.com/articles/discover-domain-concepts-in-everyday-artifacts/</link><guid isPermaLink="true">https://geminikim.com/articles/discover-domain-concepts-in-everyday-artifacts/</guid><description>How a utility bill revealed a missing delinquency concept in a repayment model and why everyday artifacts can guide software design.</description><pubDate>Mon, 04 Nov 2024 00:00:00 GMT</pubDate><category>domain-modeling</category><category>software-design</category><category>problem-solving</category></item><item><title>Rank Your Domain Concepts Before You Spend Design Effort</title><link>https://geminikim.com/articles/rank-domain-concepts-to-focus-design/</link><guid isPermaLink="true">https://geminikim.com/articles/rank-domain-concepts-to-focus-design/</guid><description>Identify a small first tier of domain concepts, separate supporting flows, and spend limited design time on the service&apos;s center.</description><pubDate>Mon, 28 Oct 2024 00:00:00 GMT</pubDate><category>domain-modeling</category><category>architecture</category><category>prioritization</category></item><item><title>Experience, Repetition, and the Developer Who Keeps Growing</title><link>https://geminikim.com/articles/grow-as-a-developer-through-varied-experience/</link><guid isPermaLink="true">https://geminikim.com/articles/grow-as-a-developer-through-varied-experience/</guid><description>How varied experience, repeated attempts, and business awareness help developers solve unfamiliar problems and keep improving.</description><pubDate>Tue, 22 Oct 2024 00:00:00 GMT</pubDate><category>career</category><category>growth</category><category>problem-solving</category></item><item><title>Before Fixing Circular Dependencies, Fix the Domain Model</title><link>https://geminikim.com/articles/fix-domain-boundaries-before-circular-dependencies/</link><guid isPermaLink="true">https://geminikim.com/articles/fix-domain-boundaries-before-circular-dependencies/</guid><description>Resolve confusing ownership and concept boundaries before using interfaces or dependency inversion to treat an apparent circular reference.</description><pubDate>Tue, 15 Oct 2024 00:00:00 GMT</pubDate><category>domain-modeling</category><category>architecture</category><category>dependencies</category></item><item><title>Create a Deliberate Messy Boundary to Keep the Core Clean</title><link>https://geminikim.com/articles/contain-messy-code-at-system-boundaries/</link><guid isPermaLink="true">https://geminikim.com/articles/contain-messy-code-at-system-boundaries/</guid><description>Contain unavoidable complexity in an explicit outer boundary so limited engineering time can protect the system&apos;s core concepts.</description><pubDate>Tue, 08 Oct 2024 00:00:00 GMT</pubDate><category>architecture</category><category>boundaries</category><category>maintainability</category></item><item><title>Nullable or Zero? Choosing a Kotlin JPA Entity ID Strategy</title><link>https://geminikim.com/articles/kotlin-jpa-new-entity-id-strategies/</link><guid isPermaLink="true">https://geminikim.com/articles/kotlin-jpa-new-entity-id-strategies/</guid><description>Compare nullable and zero-valued numeric IDs for Kotlin JPA entities, including new-entity detection, ambiguity, and verification.</description><pubDate>Tue, 01 Oct 2024 00:00:00 GMT</pubDate><category>kotlin</category><category>jpa</category><category>persistence</category></item><item><title>CS Knowledge Becomes Valuable When It Solves Real Problems</title><link>https://geminikim.com/articles/learn-computer-science-through-engineering-work/</link><guid isPermaLink="true">https://geminikim.com/articles/learn-computer-science-through-engineering-work/</guid><description>Learn computer science through real engineering problems, then show the reasoning and improvements it made possible in your work.</description><pubDate>Wed, 25 Sep 2024 00:00:00 GMT</pubDate><category>computer-science</category><category>career</category><category>engineering-practice</category></item><item><title>Layering That Teammates Can Understand—and the Build Can Enforce</title><link>https://geminikim.com/articles/define-and-enforce-layering-rules/</link><guid isPermaLink="true">https://geminikim.com/articles/define-and-enforce-layering-rules/</guid><description>Define stable layer roles, constrain optional upper layers, and automate checks only when a team needs stronger enforcement.</description><pubDate>Wed, 18 Sep 2024 00:00:00 GMT</pubDate><category>architecture</category><category>layering</category><category>static-analysis</category></item><item><title>Turn Production Incidents into Shared Domain Knowledge</title><link>https://geminikim.com/articles/turn-production-incidents-into-shared-domain-knowledge/</link><guid isPermaLink="true">https://geminikim.com/articles/turn-production-incidents-into-shared-domain-knowledge/</guid><description>Use incident reviews, working notes, concept maps, and rotated operations to reduce domain knowledge gaps across a software team.</description><pubDate>Wed, 11 Sep 2024 00:00:00 GMT</pubDate><category>domain-knowledge</category><category>team-practice</category><category>operations</category></item><item><title>One Project, Many Deployables: Drawing Boundaries by Runtime Role</title><link>https://geminikim.com/articles/separate-runnable-apps-by-operational-role/</link><guid isPermaLink="true">https://geminikim.com/articles/separate-runnable-apps-by-operational-role/</guid><description>Separate public, admin, batch, and operations workloads into runnable applications without splitting the whole codebase into separate projects too early.</description><pubDate>Wed, 04 Sep 2024 00:00:00 GMT</pubDate><category>backend</category><category>architecture</category><category>deployment</category></item><item><title>Name Readers, Finders, and Searchers by Behavior</title><link>https://geminikim.com/articles/name-readers-finders-and-searchers-by-behavior/</link><guid isPermaLink="true">https://geminikim.com/articles/name-readers-finders-and-searchers-by-behavior/</guid><description>Distinguish Reader, Finder, and Searcher classes by direct reads, added filtering, and composite searches rather than result count.</description><pubDate>Thu, 29 Aug 2024 00:00:00 GMT</pubDate><category>software-design</category><category>maintainability</category><category>backend</category></item><item><title>Measure Before Replacing Outbox Polling</title><link>https://geminikim.com/articles/measure-before-replacing-outbox-polling/</link><guid isPermaLink="true">https://geminikim.com/articles/measure-before-replacing-outbox-polling/</guid><description>Evaluate outbox polling with realistic load tests, then consider a simpler application-level delivery path before adopting log tailing.</description><pubDate>Thu, 22 Aug 2024 00:00:00 GMT</pubDate><category>architecture</category><category>performance</category><category>events</category></item><item><title>Publish Events Where the Business Flow Is Visible</title><link>https://geminikim.com/articles/publish-events-where-business-flow-is-visible/</link><guid isPermaLink="true">https://geminikim.com/articles/publish-events-where-business-flow-is-visible/</guid><description>Place event publication in the layer that understands the completed business action, while keeping implementation-specific cases explicit.</description><pubDate>Thu, 15 Aug 2024 00:00:00 GMT</pubDate><category>architecture</category><category>domain-events</category><category>layering</category></item><item><title>Compose My Page Data Without Inventing a My Domain</title><link>https://geminikim.com/articles/compose-my-page-data-without-a-my-domain/</link><guid isPermaLink="true">https://geminikim.com/articles/compose-my-page-data-without-a-my-domain/</guid><description>Build My page summaries through a dedicated composition layer while keeping user, order, and product responsibilities in their proper domains.</description><pubDate>Fri, 09 Aug 2024 00:00:00 GMT</pubDate><category>backend</category><category>architecture</category><category>api-design</category></item><item><title>Modules, Layers, and Architecture Are Different Decisions</title><link>https://geminikim.com/articles/modules-layers-and-architecture/</link><guid isPermaLink="true">https://geminikim.com/articles/modules-layers-and-architecture/</guid><description>Separate module boundaries from code-level layers and architectural style, then extract modules only when implementation needs stronger constraints.</description><pubDate>Fri, 02 Aug 2024 00:00:00 GMT</pubDate><category>architecture</category><category>modules</category><category>layering</category></item><item><title>Earn Your Interfaces: Abstraction After Evidence</title><link>https://geminikim.com/articles/interfaces-after-concrete-design/</link><guid isPermaLink="true">https://geminikim.com/articles/interfaces-after-concrete-design/</guid><description>Start with concrete code, extract interfaces from proven variation, and keep one-to-one abstractions only when they create a real boundary.</description><pubDate>Fri, 26 Jul 2024 00:00:00 GMT</pubDate><category>architecture</category><category>design-patterns</category><category>maintainability</category></item><item><title>Choose Hexagonal Architecture for a Reason</title><link>https://geminikim.com/articles/choose-hexagonal-architecture-for-a-reason/</link><guid isPermaLink="true">https://geminikim.com/articles/choose-hexagonal-architecture-for-a-reason/</guid><description>Choose hexagonal architecture when protocols, isolation, scale, or likely growth justify its extra structure—not because the label signals skill.</description><pubDate>Fri, 19 Jul 2024 00:00:00 GMT</pubDate><category>architecture</category><category>software-design</category></item><item><title>Track Database Changes with the Work That Ships Them</title><link>https://geminikim.com/articles/track-database-changes-with-releases/</link><guid isPermaLink="true">https://geminikim.com/articles/track-database-changes-with-releases/</guid><description>Collect database changes with the issue and PR that need them, test them in development, and hand off the final release set before code deployment.</description><pubDate>Sat, 13 Jul 2024 00:00:00 GMT</pubDate><category>database</category><category>deployment</category><category>operations</category></item><item><title>Authorization Without Redundant Reads</title><link>https://geminikim.com/articles/authorization-without-redundant-reads/</link><guid isPermaLink="true">https://geminikim.com/articles/authorization-without-redundant-reads/</guid><description>Resolve the logged-in user once, keep access checks focused, and separate system-wide administration from channel-level permissions.</description><pubDate>Sat, 06 Jul 2024 00:00:00 GMT</pubDate><category>authorization</category><category>architecture</category><category>testing</category></item><item><title>Design for Change with Core Ownership and Surrogate Keys</title><link>https://geminikim.com/articles/core-ownership-and-surrogate-keys/</link><guid isPermaLink="true">https://geminikim.com/articles/core-ownership-and-surrogate-keys/</guid><description>Centralize a shared registration rule in the core, escalate isolation only when needed, and keep changing business uniqueness out of the primary key.</description><pubDate>Sat, 29 Jun 2024 00:00:00 GMT</pubDate><category>architecture</category><category>modularity</category><category>database</category></item><item><title>Why a My Page Is Not a Domain</title><link>https://geminikim.com/articles/my-page-is-not-a-domain/</link><guid isPermaLink="true">https://geminikim.com/articles/my-page-is-not-a-domain/</guid><description>A My Page is a client-facing view, not a business domain. Keep orders, products, and coupons with their real owners and combine them at the boundary.</description><pubDate>Sat, 22 Jun 2024 00:00:00 GMT</pubDate><category>backend</category><category>domain-modeling</category><category>api-design</category></item><item><title>Software Is Not Done Until It Is Deployed</title><link>https://geminikim.com/articles/software-is-not-done-until-deployed/</link><guid isPermaLink="true">https://geminikim.com/articles/software-is-not-done-until-deployed/</guid><description>Stale pull requests and delayed releases make changes harder to review, deploy, diagnose, and roll back. Keep the path to production short and observable.</description><pubDate>Sun, 16 Jun 2024 00:00:00 GMT</pubDate><category>software-delivery</category><category>deployment</category><category>project-management</category></item><item><title>Separate Shared Counts from Personalized Cache State</title><link>https://geminikim.com/articles/separate-shared-and-personalized-cache-state/</link><guid isPermaLink="true">https://geminikim.com/articles/separate-shared-and-personalized-cache-state/</guid><description>Compose a reaction status from reusable queries, then cache the shared count without leaking one member’s personalized state to everyone else.</description><pubDate>Sun, 09 Jun 2024 00:00:00 GMT</pubDate><category>architecture</category><category>caching</category><category>performance</category></item><item><title>What Repeated Failure Teaches a Developer Career</title><link>https://geminikim.com/articles/developer-career-lessons-from-failure/</link><guid isPermaLink="true">https://geminikim.com/articles/developer-career-lessons-from-failure/</guid><description>Career failures become useful when they change how you verify opportunities, value trusted referrals, and revise the rules you made from earlier setbacks.</description><pubDate>Sun, 02 Jun 2024 00:00:00 GMT</pubDate><category>career</category><category>learning</category><category>resilience</category></item><item><title>One Read Model for Guests and Members</title><link>https://geminikim.com/articles/model-guest-and-member-reaction-state/</link><guid isPermaLink="true">https://geminikim.com/articles/model-guest-and-member-reaction-state/</guid><description>Return public reaction counts and member-specific state through one read flow while keeping optional identity distinct from required authentication.</description><pubDate>Sun, 26 May 2024 00:00:00 GMT</pubDate><category>api</category><category>authentication</category><category>architecture</category></item><item><title>Rebuild First, Migrate Second</title><link>https://geminikim.com/articles/rebuild-first-migrate-second/</link><guid isPermaLink="true">https://geminikim.com/articles/rebuild-first-migrate-second/</guid><description>Design a replacement system around the problems it must solve, then handle legacy data through explicit migration mappings and retirement conditions.</description><pubDate>Mon, 20 May 2024 00:00:00 GMT</pubDate><category>architecture</category><category>database</category><category>migration</category></item><item><title>Modeling Reactions from Requirements to Scale</title><link>https://geminikim.com/articles/model-reactions-for-requirements-and-scale/</link><guid isPermaLink="true">https://geminikim.com/articles/model-reactions-for-requirements-and-scale/</guid><description>Turn a vague like-button request into a reaction model by clarifying policy, estimating data growth, and planning when count queries must change.</description><pubDate>Mon, 13 May 2024 00:00:00 GMT</pubDate><category>architecture</category><category>database</category><category>performance</category></item><item><title>Designing Domain Models Beyond the Shape of the UI</title><link>https://geminikim.com/articles/decouple-ui-from-domain-models/</link><guid isPermaLink="true">https://geminikim.com/articles/decouple-ui-from-domain-models/</guid><description>A tree-shaped API does not require a tree-shaped domain. Keep the client contract at the presentation boundary and compose it from internal concepts.</description><pubDate>Mon, 06 May 2024 00:00:00 GMT</pubDate><category>backend</category><category>architecture</category><category>api-design</category></item><item><title>Put Logic Where Change Is Cheapest: Client vs. Server</title><link>https://geminikim.com/articles/split-client-server-responsibility-by-change-cost/</link><guid isPermaLink="true">https://geminikim.com/articles/split-client-server-responsibility-by-change-cost/</guid><description>Place display-only work near the UI, but centralize meaningful or changing values when multiple clients and shipped app versions make updates expensive.</description><pubDate>Tue, 30 Apr 2024 00:00:00 GMT</pubDate><category>api-design</category><category>client-server</category><category>backward-compatibility</category></item><item><title>Don&apos;t Distort Production Code Just to Make Tests Easier</title><link>https://geminikim.com/articles/keep-test-convenience-from-distorting-production-code/</link><guid isPermaLink="true">https://geminikim.com/articles/keep-test-convenience-from-distorting-production-code/</guid><description>Change production code when its behavior becomes clearer or legacy code needs a testing seam—not merely to expose values or methods that only tests use.</description><pubDate>Tue, 23 Apr 2024 00:00:00 GMT</pubDate><category>testing</category><category>refactoring</category><category>legacy-code</category></item><item><title>Modernize Legacy Systems Gradually—and Treat Caches as Operations</title><link>https://geminikim.com/articles/legacy-modernization-and-cache-operations/</link><guid isPermaLink="true">https://geminikim.com/articles/legacy-modernization-and-cache-operations/</guid><description>Choose legacy boundaries carefully, change them in small steps, and add a shared cache only after DB work and deployment failure modes are understood.</description><pubDate>Tue, 16 Apr 2024 00:00:00 GMT</pubDate><category>legacy</category><category>cache</category><category>operations</category></item><item><title>Reversible Design Is the Antidote to Overengineering</title><link>https://geminikim.com/articles/reversible-design-against-overengineering/</link><guid isPermaLink="true">https://geminikim.com/articles/reversible-design-against-overengineering/</guid><description>Build the requirement in front of you, look only a little beyond it, and keep speculative structures cheap to expand, remove, or replace.</description><pubDate>Tue, 09 Apr 2024 00:00:00 GMT</pubDate><category>software-design</category><category>overengineering</category><category>data-modeling</category></item><item><title>Win Technical Arguments with Small Proofs, Not Opinions</title><link>https://geminikim.com/articles/persuade-with-small-prototypes-and-evidence/</link><guid isPermaLink="true">https://geminikim.com/articles/persuade-with-small-prototypes-and-evidence/</guid><description>Diagnose why a proposal is blocked, build a small proof, strengthen your reasoning, understand the opposing case, and treat new technology as company risk.</description><pubDate>Wed, 03 Apr 2024 00:00:00 GMT</pubDate><category>communication</category><category>teamwork</category><category>technical-decisions</category></item><item><title>A Practical Entry Strategy for a Frozen Junior Developer Market</title><link>https://geminikim.com/articles/entering-a-frozen-junior-developer-market/</link><guid isPermaLink="true">https://geminikim.com/articles/entering-a-frozen-junior-developer-market/</guid><description>In a tight 2024 hiring market, broaden the first-company search, turn real work into problem-solving evidence, and show reasoning rather than a technology list.</description><pubDate>Wed, 27 Mar 2024 00:00:00 GMT</pubDate><category>career</category><category>hiring</category><category>junior-developer</category></item><item><title>Build APIs for Clarity, Not REST Purity</title><link>https://geminikim.com/articles/design-apis-for-clarity-not-rest-purity/</link><guid isPermaLink="true">https://geminikim.com/articles/design-apis-for-clarity-not-rest-purity/</guid><description>Use REST ideas where they improve an HTTP contract, but let client clarity, team consistency, domain boundaries, and change cost decide the API.</description><pubDate>Wed, 20 Mar 2024 00:00:00 GMT</pubDate><category>api-design</category><category>rest</category><category>http</category></item><item><title>Validate at the Boundary, Simplify the Core</title><link>https://geminikim.com/articles/validate-at-boundaries-keep-core-flows-simple/</link><guid isPermaLink="true">https://geminikim.com/articles/validate-at-boundaries-keep-core-flows-simple/</guid><description>Turn API input into complete business values at the presentation boundary, keep nulls out of inner flows, and validate stored data when it enters the system.</description><pubDate>Wed, 13 Mar 2024 00:00:00 GMT</pubDate><category>validation</category><category>api-design</category><category>layered-architecture</category></item><item><title>From SI to Product Development: Turn Job Requirements into a Learning Plan</title><link>https://geminikim.com/articles/move-from-si-to-product-development/</link><guid isPermaLink="true">https://geminikim.com/articles/move-from-si-to-product-development/</guid><description>A move from contract work to a product team depended on help and luck; the repeatable strategy is to study target job requirements and build relevant experience.</description><pubDate>Thu, 07 Mar 2024 00:00:00 GMT</pubDate><category>career</category><category>growth</category></item><item><title>Your First Test Can Be Messy—Refactor It Later</title><link>https://geminikim.com/articles/start-tests-then-refactor-them/</link><guid isPermaLink="true">https://geminikim.com/articles/start-tests-then-refactor-them/</guid><description>Start with the test that proves the behavior you care about, mock enough to make it run, and improve test design through repeated use and review.</description><pubDate>Thu, 29 Feb 2024 00:00:00 GMT</pubDate><category>testing</category><category>refactoring</category><category>backend</category></item><item><title>Keep API Request Models Out of the Core Domain</title><link>https://geminikim.com/articles/separate-api-requests-from-domain-models/</link><guid isPermaLink="true">https://geminikim.com/articles/separate-api-requests-from-domain-models/</guid><description>Convert external request objects into business-owned values at the presentation boundary so the API depends inward and the core never depends back.</description><pubDate>Thu, 22 Feb 2024 00:00:00 GMT</pubDate><category>backend</category><category>architecture</category><category>api-design</category><category>modularity</category></item><item><title>Design Performance Tests from Real Traffic Shapes</title><link>https://geminikim.com/articles/performance-tests-from-traffic-and-failure-models/</link><guid isPermaLink="true">https://geminikim.com/articles/performance-tests-from-traffic-and-failure-models/</guid><description>Estimate volume and arrival patterns before choosing a load test, add deliberate headroom, and require evidence only where traffic risk justifies it.</description><pubDate>Thu, 15 Feb 2024 00:00:00 GMT</pubDate><category>performance</category><category>testing</category><category>operations</category></item><item><title>Foreign Keys Are an Operational Tradeoff, Not a Rule</title><link>https://geminikim.com/articles/choose-foreign-keys-for-operational-reality/</link><guid isPermaLink="true">https://geminikim.com/articles/choose-foreign-keys-for-operational-reality/</guid><description>Choose foreign keys, indexes, and ORM mappings from integrity needs, incident response, deployment practice, and who operates the database.</description><pubDate>Fri, 09 Feb 2024 00:00:00 GMT</pubDate><category>database</category><category>operations</category><category>jpa</category></item><item><title>Give Cross-Domain Behavior to the Domain That Owns It</title><link>https://geminikim.com/articles/assign-cross-domain-actions-by-ownership/</link><guid isPermaLink="true">https://geminikim.com/articles/assign-cross-domain-actions-by-ownership/</guid><description>Before placing a caller-owned interface across modules, identify which domain owns the action and let callers depend on that capability.</description><pubDate>Fri, 02 Feb 2024 00:00:00 GMT</pubDate><category>backend</category><category>domain-modeling</category><category>modularity</category></item><item><title>Who Owns the Enum? Dependency Design Across Domain Modules</title><link>https://geminikim.com/articles/keep-domain-enums-in-the-domain-module/</link><guid isPermaLink="true">https://geminikim.com/articles/keep-domain-enums-in-the-domain-module/</guid><description>Put a business enum with its domain, let storage depend inward, and use a small shared enum module only while the domain boundary is still emerging.</description><pubDate>Fri, 26 Jan 2024 00:00:00 GMT</pubDate><category>modularity</category><category>architecture</category><category>dependencies</category></item><item><title>Provider Identity and Authentication Boundaries for Platform APIs</title><link>https://geminikim.com/articles/design-provider-identity-and-auth-boundaries/</link><guid isPermaLink="true">https://geminikim.com/articles/design-provider-identity-and-auth-boundaries/</guid><description>How a small platform API resolves provider keys into a domain identity, separates tenant data, and chooses an authentication boundary that fits its scale.</description><pubDate>Fri, 19 Jan 2024 00:00:00 GMT</pubDate><category>api-design</category><category>backend</category><category>architecture</category></item><item><title>Where Cross-Domain Coordination Code Belongs</title><link>https://geminikim.com/articles/place-cross-domain-work-by-business-ownership/</link><guid isPermaLink="true">https://geminikim.com/articles/place-cross-domain-work-by-business-ownership/</guid><description>Use business ownership, cohesion, imports, and a package-move experiment to place code that coordinates a primary action with another domain&apos;s rule.</description><pubDate>Sat, 13 Jan 2024 00:00:00 GMT</pubDate><category>packaging</category><category>domain-modeling</category><category>architecture</category></item><item><title>Domain Models First: A Conservative Approach to JPA Associations</title><link>https://geminikim.com/articles/jpa-domain-modeling-without-association-overload/</link><guid isPermaLink="true">https://geminikim.com/articles/jpa-domain-modeling-without-association-overload/</guid><description>A cautious way to map JPA entities: start with IDs, add associations only when lifecycles truly align, and model business concepts independently.</description><pubDate>Sat, 06 Jan 2024 00:00:00 GMT</pubDate><category>jpa</category><category>domain-modeling</category><category>backend</category></item><item><title>You Can Practice High-Traffic Engineering Without Real Traffic</title><link>https://geminikim.com/articles/high-traffic-experience-without-traffic/</link><guid isPermaLink="true">https://geminikim.com/articles/high-traffic-experience-without-traffic/</guid><description>Build and operate a small service, create load deliberately, and show how you found and fixed bottlenecks without pretending a load test equals production experience.</description><pubDate>Sat, 09 Dec 2023 00:00:00 GMT</pubDate><category>performance</category><category>career</category><category>backend</category></item><item><title>Reliable Database Tests Without a Shared Test Database</title><link>https://geminikim.com/articles/reliable-database-tests-with-testcontainers/</link><guid isPermaLink="true">https://geminikim.com/articles/reliable-database-tests-with-testcontainers/</guid><description>Choose mocks, an in-memory database, Testcontainers, or a real database by the failure you need to catch, while keeping ordinary tests isolated from shared infrastructure.</description><pubDate>Mon, 04 Dec 2023 00:00:00 GMT</pubDate><category>testing</category><category>databases</category><category>backend</category></item><item><title>Do Not Create a DTO for Every Layer by Habit</title><link>https://geminikim.com/articles/dto-boundaries-between-layers/</link><guid isPermaLink="true">https://geminikim.com/articles/dto-boundaries-between-layers/</guid><description>Use DTOs where data crosses a boundary with a different contract. Mapping has a cost, but so does letting external request shapes define the inside of a service.</description><pubDate>Thu, 30 Nov 2023 00:00:00 GMT</pubDate><category>backend</category><category>architecture</category><category>api-design</category></item><item><title>Git History Is a Team Asset, Not a Work Diary</title><link>https://geminikim.com/articles/practical-git-commit-branch-rules/</link><guid isPermaLink="true">https://geminikim.com/articles/practical-git-commit-branch-rules/</guid><description>Split work before polishing commits, shape pull requests for reviewers, and leave a history that helps the next engineer understand changes and recover a release.</description><pubDate>Sat, 25 Nov 2023 00:00:00 GMT</pubDate><category>git</category><category>collaboration</category><category>software-engineering</category></item><item><title>Put Circuit Breakers Next to the Failing I/O</title><link>https://geminikim.com/articles/circuit-breaker-placement/</link><guid isPermaLink="true">https://geminikim.com/articles/circuit-breaker-placement/</guid><description>Circuit breakers, timeouts, cache fallbacks, and remote-call policies belong near the implementation that performs the I/O, while domain code chooses the required behavior.</description><pubDate>Tue, 21 Nov 2023 00:00:00 GMT</pubDate><category>backend</category><category>reliability</category><category>architecture</category></item><item><title>Timeouts Are Product Decisions, Not Just Client Settings</title><link>https://geminikim.com/articles/timeouts-retries-and-failure-propagation/</link><guid isPermaLink="true">https://geminikim.com/articles/timeouts-retries-and-failure-propagation/</guid><description>Design timeout, retry, and recovery policies from the user&apos;s waiting budget and the uncertainty of each failure instead of applying one retry rule everywhere.</description><pubDate>Thu, 16 Nov 2023 00:00:00 GMT</pubDate><category>backend</category><category>reliability</category><category>distributed-systems</category></item><item><title>Do Not Split Modules Before the Domain Has Matured</title><link>https://geminikim.com/articles/domain-maturity-and-module-boundaries/</link><guid isPermaLink="true">https://geminikim.com/articles/domain-maturity-and-module-boundaries/</guid><description>Domain maturity comes from understanding policy, behavior, and operating reality. Let those lessons reveal module boundaries instead of freezing guesses too early.</description><pubDate>Sun, 12 Nov 2023 00:00:00 GMT</pubDate><category>architecture</category><category>domain-driven-design</category><category>backend</category></item><item><title>Grow Software One Boundary at a Time</title><link>https://geminikim.com/articles/grow-software-in-stages/</link><guid isPermaLink="true">https://geminikim.com/articles/grow-software-in-stages/</guid><description>Start with working code, then extract functions, classes, packages, modules, and projects as real cohesion and scale make each stronger boundary necessary.</description><pubDate>Tue, 07 Nov 2023 00:00:00 GMT</pubDate><category>software-design</category><category>architecture</category><category>modularity</category></item><item><title>Keep Layers Logical and Packages Cohesive</title><link>https://geminikim.com/articles/cohesive-packages-with-modules-and-layers/</link><guid isPermaLink="true">https://geminikim.com/articles/cohesive-packages-with-modules-and-layers/</guid><description>Modules, packages, and architectural layers solve different problems. Package related behavior together and let layers describe roles without scattering a feature.</description><pubDate>Thu, 02 Nov 2023 00:00:00 GMT</pubDate><category>architecture</category><category>modularity</category><category>packaging</category></item><item><title>Upgrade Dependencies Before the Gap Becomes a Project</title><link>https://geminikim.com/articles/frequent-dependency-upgrades/</link><guid isPermaLink="true">https://geminikim.com/articles/frequent-dependency-upgrades/</guid><description>Frequent, prioritized dependency upgrades keep change small, expose compatibility problems early, and prevent a maintained service from quietly accumulating debt.</description><pubDate>Sun, 29 Oct 2023 00:00:00 GMT</pubDate><category>dependencies</category><category>maintenance</category><category>technical-debt</category></item><item><title>Software Should Survive the Developer Who Built It</title><link>https://geminikim.com/articles/software-that-survives-developer-departure/</link><guid isPermaLink="true">https://geminikim.com/articles/software-that-survives-developer-departure/</guid><description>Good company software reduces debt, fits the team&apos;s operating ability, and remains understandable and repairable after its original developer leaves.</description><pubDate>Tue, 24 Oct 2023 00:00:00 GMT</pubDate><category>maintainability</category><category>engineering-culture</category><category>software-design</category></item><item><title>Unit Tests Should Preserve Business Intent</title><link>https://geminikim.com/articles/unit-tests-protect-business-intent/</link><guid isPermaLink="true">https://geminikim.com/articles/unit-tests-protect-business-intent/</guid><description>A business-layer unit test is useful when it guides design, records meaningful behavior, or makes the next developer reconsider a risky change.</description><pubDate>Fri, 20 Oct 2023 00:00:00 GMT</pubDate><category>testing</category><category>architecture</category><category>maintainability</category></item><item><title>When an AI Agent Calls the Same Tool Twice</title><link>https://geminikim.com/articles/idempotent-ai-tool-calls/</link><guid isPermaLink="true">https://geminikim.com/articles/idempotent-ai-tool-calls/</guid><description>Retries are normal in distributed systems and AI workflows. Use database constraints, idempotency keys, and bounded retries to prevent duplicate side effects.</description><pubDate>Sun, 15 Oct 2023 00:00:00 GMT</pubDate><category>ai-agents</category><category>backend</category><category>reliability</category></item><item><title>Multi-Module Too Early Makes Design Harder</title><link>https://geminikim.com/articles/premature-multi-module-complexity/</link><guid isPermaLink="true">https://geminikim.com/articles/premature-multi-module-complexity/</guid><description>Modules should enforce boundaries discovered through implementation, not freeze guessed domains or mirror an architecture diagram before the software is understood.</description><pubDate>Wed, 11 Oct 2023 00:00:00 GMT</pubDate><category>architecture</category><category>modularity</category><category>software-design</category></item><item><title>Gradle Dependency Scopes Are Architectural Boundaries</title><link>https://geminikim.com/articles/gradle-dependency-boundaries/</link><guid isPermaLink="true">https://geminikim.com/articles/gradle-dependency-boundaries/</guid><description>Use Gradle implementation, api, runtimeOnly, and compileOnly deliberately to express module access, prevent accidental coupling, and preserve design intent.</description><pubDate>Fri, 06 Oct 2023 00:00:00 GMT</pubDate><category>gradle</category><category>architecture</category><category>modularity</category></item><item><title>Operate Your Toy Project Before Calling It a Service</title><link>https://geminikim.com/articles/operate-toy-project-for-real-users/</link><guid isPermaLink="true">https://geminikim.com/articles/operate-toy-project-for-real-users/</guid><description>A toy project becomes service experience only after launch: pick one goal, find real users, watch retention, and learn when to stop.</description><pubDate>Mon, 02 Oct 2023 00:00:00 GMT</pubDate><category>product</category><category>operations</category><category>side-project</category></item><item><title>Isolate Admin Work from the Service Domain</title><link>https://geminikim.com/articles/isolate-admin-from-domain/</link><guid isPermaLink="true">https://geminikim.com/articles/isolate-admin-from-domain/</guid><description>Admin APIs have different queries, mutation needs, and release risks. Isolate them by module or repository instead of letting operational convenience reshape the core service.</description><pubDate>Wed, 27 Sep 2023 00:00:00 GMT</pubDate><category>architecture</category><category>backend</category><category>admin</category></item><item><title>Use Reader and Writer Components to Reveal Business Flow</title><link>https://geminikim.com/articles/reader-writer-business-flow/</link><guid isPermaLink="true">https://geminikim.com/articles/reader-writer-business-flow/</guid><description>Reader and writer components can hide storage details, narrow change, and let the business layer show policy, but only when the software&apos;s lifetime justifies them.</description><pubDate>Fri, 22 Sep 2023 00:00:00 GMT</pubDate><category>software-design</category><category>backend</category><category>maintainability</category></item><item><title>Carry One Trace ID across Distributed Services</title><link>https://geminikim.com/articles/trace-id-across-distributed-services/</link><guid isPermaLink="true">https://geminikim.com/articles/trace-id-across-distributed-services/</guid><description>Logs become operationally useful when one request can be followed across HTTP calls and asynchronous events without exposing sensitive data or flooding storage.</description><pubDate>Mon, 18 Sep 2023 00:00:00 GMT</pubDate><category>observability</category><category>distributed-systems</category><category>backend</category></item><item><title>Define Problems from the User&apos;s Perspective</title><link>https://geminikim.com/articles/define-problems-from-user-perspective/</link><guid isPermaLink="true">https://geminikim.com/articles/define-problems-from-user-perspective/</guid><description>Problem-solving improves when you separate technical load from product value, launch what you build, and keep asking why a user would choose it.</description><pubDate>Wed, 13 Sep 2023 00:00:00 GMT</pubDate><category>product</category><category>career</category><category>problem-solving</category></item><item><title>Reuse Below the Use-Case Layer</title><link>https://geminikim.com/articles/reuse-below-use-case-layer/</link><guid isPermaLink="true">https://geminikim.com/articles/reuse-below-use-case-layer/</guid><description>When use cases call one another for reuse, business changes spread and cycles follow. Compose above them or extract focused implementation components below them.</description><pubDate>Sat, 09 Sep 2023 00:00:00 GMT</pubDate><category>architecture</category><category>backend</category><category>software-design</category></item><item><title>Choose Experience and Judgment over Development Jargon</title><link>https://geminikim.com/articles/experience-over-development-jargon/</link><guid isPermaLink="true">https://geminikim.com/articles/experience-over-development-jargon/</guid><description>Theories and patterns are useful references, but a developer still needs to explain the code, its tradeoffs, and what happened when it was operated.</description><pubDate>Mon, 04 Sep 2023 00:00:00 GMT</pubDate><category>career</category><category>software-design</category><category>collaboration</category></item><item><title>How to Split a Large Service Class by Responsibility and Layer</title><link>https://geminikim.com/articles/split-large-service-class/</link><guid isPermaLink="true">https://geminikim.com/articles/split-large-service-class/</guid><description>Use constructor dependencies and imports to diagnose an oversized service, then separate cohesive responsibilities before adding another architecture label.</description><pubDate>Thu, 31 Aug 2023 00:00:00 GMT</pubDate><category>backend</category><category>refactoring</category><category>architecture</category></item><item><title>Choose Normalization from Requirements and Object Relationships</title><link>https://geminikim.com/articles/normalization-from-requirements/</link><guid isPermaLink="true">https://geminikim.com/articles/normalization-from-requirements/</guid><description>Database normalization is not a score to maximize. Decide from change semantics, query cost, and the relationships the data is meant to preserve.</description><pubDate>Sat, 26 Aug 2023 00:00:00 GMT</pubDate><category>database</category><category>backend</category><category>design</category></item></channel></rss>