yutna
- 67 skills
- 0 followers
- 14 hours ago last updated
- ▌ Oo Recognising Antipatterns · yutna bundleUse when a review names an antipattern such as a god class, lava flow or poltergeist, or when sorting code smells into the rules they break.
- ▌ Oo Working With Legacy Code · yutna bundleUse when changing software that has no tests, when an old class must change before it can be tested, or replacing an old system piece by piece.
- ▌ Oo Web Components · yutna bundleUse when a custom element that extends HTMLElement reads attributes in its constructor, exposes attributes and properties, or dispatches custom events.
- ▌ Oo Designing For Testability · yutna bundleUse when tests depend on today's date, random values or generated ids, when a constructor does real work, or code is made public only for tests.
- ▌ Oo Encapsulating What Varies · yutna bundleUse when one requirement keeps changing, when adding a case means editing working code, or when deciding how flexible a design should be.
- ▌ Oo Assigning Responsibilities · yutna bundleUse when deciding which class owns a behaviour, where a method lives, which object holds its data or creates another, or when a class does too much.
- ▌ Oo Constructing Valid Objects · yutna bundleUse when an object can exist half-built, needs setup calls after its constructor, takes a long parameter list, or needs a factory or builder.
- ▌ Oo Crossing System Boundaries · yutna bundleUse when an API or message must keep its shape as the model changes, when mapping partner data into the domain, or a contract needs a version.
- ▌ Oo Honouring Substitutability · yutna bundleUse when a subclass throws or breaks its parent's promise, when callers check which subtype they hold, or when deciding if a class may be extended.
- ▌ Oo Naming Classes And Methods · yutna bundleUse when choosing what to call a class or method, when names end in Manager, Helper or Util, or when a name no longer says what the code does.
- ▌ Oo Working Within A Framework · yutna bundleUse when a framework wants domain classes to extend its base class, offer setters or carry its markers, or deciding how far to go along with it.
- ▌ Oo Java Jakarta Ee · yutna bundleUse when Java code on Jakarta EE picks a CDI bean or a @Stateless EJB, or a container transaction commits work that a refusal should undo.
- ▌ Oo Commenting What Code Cannot · yutna bundleUse when comments or notes repeat the code or contradict it, or when a note must explain a reason or a warning no well-chosen name can explain.
- ▌ Oo Designing Failure Behaviour · yutna bundleUse when a method answers null for nothing found, when callers ignore or catch every exception, or when designing a module's error types.
- ▌ Oo Documenting Design Decisions · yutna bundleUse when nobody remembers why a design is this way, when a choice is costly to reverse, or before drawing a picture of the system for a redesign.
- ▌ Oo Modeling Values And Entities · yutna bundleUse when picking value or entity, when ids are raw strings or numbers, when editing one object changes another, or equal objects compare unequal.
- ▌ Oo Separating Reads From Writes · yutna bundleUse when screens need data shaped unlike the model, when reads slow down writes, or when weighing read models, projections or event sourcing.
- ▌ Oo Speaking The Domain Language · yutna bundleUse when code words differ from what staff say, when staff talk about something no class models, or two teams mean different things by one word.
- ▌ Oo Testing Object Oriented Code · yutna bundleUse when writing tests for objects, when tests break although behaviour did not change, or when choosing a mock, stub or fake.
- ▌ Oo Limiting What An Object Knows · yutna bundleUse when code reaches through a chain of objects, when a method works mostly on another object's data, or when a class only forwards calls.
- ▌ Oo Applying Functional Techniques · yutna bundleUse when calculating also writes or sends so tests need mocks, when a helper changes what it was handed, or when borrowing functional style.
- ▌ Oo Patterns The Language Provides · yutna bundleUse when strategy or command classes could be functions, when writing an iterator or visitor by hand, or when the language builds in the pattern.
- ▌ Oo Making Illegal States Impossible · yutna bundleUse when flags or optional fields allow forbidden states, such as accepted and declined at once, or a reason set when nothing was cancelled.
- ▌ Oo Refactoring Toward Object Design · yutna bundleUse when restructuring working code without changing what it does, when a refactoring grew too big to finish, or when moving toward a pattern.
- ▌ Oo Typescript Angular · yutna bundleUse when Angular code picks providedIn or a component's providers, keeps shared state in a service with RxJS or signals, or chooses an injection token.
- ▌ Oo Encapsulating State And Behaviour · yutna bundleUse when callers check an object's state to decide for it, when any caller can set it into a broken state, or when a getter leaks a collection.
- ▌ Oo Separating Presentation From Domain · yutna bundleUse when choosing MVC, MVP or MVVM for a screen, when a screen binds straight to domain objects, or when a background task updates a screen.
- ▌ Oo Choosing Composition Over Inheritance · yutna bundleUse when a subclass only reuses code, when a base class change breaks its subclasses, or when choosing between extending a class and wrapping it.
- ▌ Oo Replacing Conditionals With Polymorphism · yutna bundleUse when the same switch or if-chain on a type or status repeats across methods, or when choosing subclasses or pattern matching for cases.
- ▌ Oo Java · yutna bundleUse when plain Java code with no framework needs a record or a sealed type, equals and hashCode, a checked exception, or a choice to make a class final.
- ▌ Oo Ruby · yutna bundleUse when plain Ruby with no framework leans on duck typing, mixes in a module, defines a value with Data, or reaches for method_missing or send.
- ▌ Oo Design · yutna bundleUse when starting a new module, feature or system in an object-oriented codebase, sizing design, or unsure which object rule applies.
- ▌ Oo Csharp · yutna bundleUse when plain C# with no framework needs a record or a struct, nullable reference types, a default interface member, or async and await.
- ▌ Oo Kotlin · yutna bundleUse when plain Kotlin code with no framework needs a data class or a sealed type, a choice of nullable types, delegation with by, or extension functions.
- ▌ Oo Python · yutna bundleUse when plain Python with no framework needs a Protocol or an ABC, a frozen dataclass, a mixin and its MRO, or a property instead of a setter.
- ▌ Oo Java Swing · yutna bundleUse when Java Swing code updates components off the event dispatch thread, decides rules inside listeners, or backs a JTable with domain objects.
- ▌ Oo Javascript · yutna bundleUse when plain JavaScript (JS), with no framework or types, has no interface for a contract, or needs private state, frozen values or classes, not prototypes.
- ▌ Oo Ruby Rails · yutna bundleUse when a Rails app's Active Record models gather rules, callbacks hide side effects, or a service or query object is being weighed.
- ▌ Oo Typescript · yutna bundleUse when plain TypeScript (TS) with no framework mixes up same-shaped types, or needs private fields, an abstract class, a decorator or a discriminated union.
- ▌ Oo Bounding Contexts · yutna bundleUse when splitting a large model between teams, choosing how parts with their own models talk, or deciding which parts to build or buy.
- ▌ Oo Choosing A Pattern · yutna bundleUse when picking a design pattern for a problem, when a pattern was added before its problem, or when deciding if a pattern still pays its way.
- ▌ Oo Organising Modules · yutna bundleUse when grouping classes into packages, when packages depend on each other in a cycle, or choosing between a modular monolith and services.
- ▌ Oo Taming Persistence · yutna bundleUse when choosing active record or a data mapper, when a list fires one query per row, or when lazily loaded data fails outside its session.
- ▌ Oo Java Javafx · yutna bundleUse when JavaFX code binds controls to domain objects, decides where a view model's properties live, or changes the scene graph from a Task's thread.
- ▌ Oo Java Spring · yutna bundleUse when Java code on Spring wires beans with @Autowired or annotations, places @Transactional, or gives a JPA entity setters instead of its own rules.
- ▌ Oo Diagnosing Coupling · yutna bundleUse when a change ripples through many classes, a part is hard to change or test alone, or you need to judge how tightly two parts are tied.
- ▌ Oo Layering The System · yutna bundleUse when choosing layered, hexagonal or clean architecture, when an inner layer imports an outer one, or a screen needs its framework in tests.
- ▌ Oo Modeling Lifecycles · yutna bundleUse when deciding which status transitions are allowed, when something cancelled can still go ahead, or a closed one is reopened and edited.
- ▌ Oo Designing Aggregates · yutna bundleUse when choosing what one transaction keeps consistent, when two people saving at the same time break it, or one load pulls in too much.
- ▌ Oo Designing Interfaces · yutna bundleUse when an interface has methods its callers never use, when it copies public members of one type, or when picking interface or abstract base.
- ▌ Oo Making Work Reliable · yutna bundleUse when calls to another system hang, time out or fail midway, when a retry could do the work twice, or a process spans steps that may fail.
- ▌ Oo Placing Domain Logic · yutna bundleUse when choosing a domain service, entity method or application service, when use cases repeat one check, or picking scripts or a domain model.
- ▌ Oo Hiding Implementation · yutna bundleUse when many classes know how another stores or formats data, when callers must handle its internal errors, or must call its steps in order.
- ▌ Oo Managing Shared State · yutna bundleUse when several threads or tasks use one object at once, when a cache or counter goes wrong under load, or when choosing locks or one owner.
- ▌ Oo Designing Repositories · yutna bundleUse when designing a repository, when it grows a find method per screen, returns rows instead of objects, or updates single fields.
- ▌ Oo Inverting Dependencies · yutna bundleUse when domain code depends on a database, framework or clock, when an object builds or looks up its collaborators, or when wiring objects.
- ▌ Oo Csharp Aspnet · yutna bundleUse when ASP.NET Core code picks a scoped or singleton lifetime, tracks entities with EF Core, or keeps logic out of MapPost endpoints and middleware.
- ▌ Oo Python Django · yutna bundleUse when a Django project's models, views or signals carry business rules, or its apps are being drawn as boundaries.
- ▌ Oo Deciding Object Or Data · yutna bundleUse when deciding if something should be a class or just data, when classes are only getters and setters, or when shaping DTOs and records.
- ▌ Oo Reviewing Object Design · yutna bundleUse when reviewing a pull request or a design for object-design problems, or when deciding which review findings must block a merge.
- ▌ Oo Designing What To Record · yutna bundleUse when deciding what to log, measure or trace, when an incident cannot be explained from the records, or staff actions need an audit trail.
- ▌ Oo Publishing Domain Events · yutna bundleUse when other parts react after a change is saved, when a use case grows a step per reaction, or a message goes out before the change commits.
- ▌ Gherkin Discovery · yutna bundleTurn a vague story, ticket, or requirement into agreed concrete examples before any scenario is written. Use when acceptance criteria are missing or ambiguous, when a feature request is too abstract to build, when the team disagrees about scope, when nobody can say what "done" means, or when asked to find edge cases and open questions for a piece of work. Produces a set of business rules with worked examples and unanswered questions, ready to be phrased as Gherkin.
- ▌ Gherkin Automation · yutna bundleImplement and repair the code behind Gherkin steps. Use when writing or refactoring step definitions, wiring glue code to an application, sharing state between steps, building test data, adding hooks, diagnosing why an individual scenario is flaky or slow, resolving undefined or ambiguous step errors, or deciding what belongs in a scenario versus a unit test. Covers Cucumber Expressions, parameter types, the layering rule, isolation, determinism, and per-language notes for JavaScript, Java, Python, .NET, Go, and Ruby.
- ▌ Gherkin Suite Design · yutna bundleShape a whole body of feature files rather than one scenario. Use when setting up a BDD suite from scratch, deciding how to organise or split feature files, designing a tagging strategy, publishing scenarios as living documentation, deciding what runs in continuous integration and when, or introducing BDD into a codebase that already has tests. Concerns the shape of the whole suite, not the code behind any one step. Covers folder layout, feature granularity, tag taxonomy, suite health metrics, migration, and failure triage.
- ▌ Gherkin Scenario Review · yutna bundleCritique and repair feature files that already exist. Use when reviewing a pull request that touches .feature files, when asked whether a scenario is any good, when a suite has grown unreadable or brittle, when auditing acceptance criteria inherited from another team, or when asked to clean up or refactor existing Gherkin. Supplies a catalogue of scenario smells with the rewrite for each, a review rubric, and guidance on delivering the feedback.
- ▌ Gherkin Scenario Writing · yutna bundleWrite Gherkin feature files and scenarios that read as behaviour rather than test scripts. Use when drafting or rewriting a .feature file, turning acceptance criteria or a user story into Given/When/Then, naming scenarios, choosing between a Scenario and a Scenario Outline, deciding whether a Background is justified, or when asked what a scenario should say. Covers the full Gherkin keyword set, declarative phrasing, data tables, doc strings, tags, and localisation.