all publishers

yutna

@yutna source repo

67 published skills

  1. ▌
    Oo Recognising Antipatterns · yutna bundle
    Use 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.
    0 installs
  2. ▌
    Oo Working With Legacy Code · yutna bundle
    Use 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.
    0 installs
  3. ▌
    Oo Web Components · yutna bundle
    Use when a custom element that extends HTMLElement reads attributes in its constructor, exposes attributes and properties, or dispatches custom events.
    0 installs
  4. ▌
    Oo Designing For Testability · yutna bundle
    Use 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.
    0 installs
  5. ▌
    Oo Encapsulating What Varies · yutna bundle
    Use when one requirement keeps changing, when adding a case means editing working code, or when deciding how flexible a design should be.
    0 installs
  6. ▌
    Oo Assigning Responsibilities · yutna bundle
    Use 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.
    0 installs
  7. ▌
    Oo Constructing Valid Objects · yutna bundle
    Use when an object can exist half-built, needs setup calls after its constructor, takes a long parameter list, or needs a factory or builder.
    0 installs
  8. ▌
    Oo Crossing System Boundaries · yutna bundle
    Use 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.
    0 installs
  9. ▌
    Oo Honouring Substitutability · yutna bundle
    Use 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.
    0 installs
  10. ▌
    Oo Naming Classes And Methods · yutna bundle
    Use 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.
    0 installs
  11. ▌
    Oo Working Within A Framework · yutna bundle
    Use 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.
    0 installs
  12. ▌
    Oo Java Jakarta Ee · yutna bundle
    Use 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.
    0 installs
  13. ▌
    Oo Commenting What Code Cannot · yutna bundle
    Use 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.
    0 installs
  14. ▌
    Oo Designing Failure Behaviour · yutna bundle
    Use when a method answers null for nothing found, when callers ignore or catch every exception, or when designing a module's error types.
    0 installs
  15. ▌
    Oo Documenting Design Decisions · yutna bundle
    Use 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.
    0 installs
  16. ▌
    Oo Modeling Values And Entities · yutna bundle
    Use when picking value or entity, when ids are raw strings or numbers, when editing one object changes another, or equal objects compare unequal.
    0 installs
  17. ▌
    Oo Separating Reads From Writes · yutna bundle
    Use when screens need data shaped unlike the model, when reads slow down writes, or when weighing read models, projections or event sourcing.
    0 installs
  18. ▌
    Oo Speaking The Domain Language · yutna bundle
    Use 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.
    0 installs
  19. ▌
    Oo Testing Object Oriented Code · yutna bundle
    Use when writing tests for objects, when tests break although behaviour did not change, or when choosing a mock, stub or fake.
    0 installs
  20. ▌
    Oo Limiting What An Object Knows · yutna bundle
    Use 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.
    0 installs
  21. ▌
    Oo Applying Functional Techniques · yutna bundle
    Use when calculating also writes or sends so tests need mocks, when a helper changes what it was handed, or when borrowing functional style.
    0 installs
  22. ▌
    Oo Patterns The Language Provides · yutna bundle
    Use when strategy or command classes could be functions, when writing an iterator or visitor by hand, or when the language builds in the pattern.
    0 installs
  23. ▌
    Oo Making Illegal States Impossible · yutna bundle
    Use when flags or optional fields allow forbidden states, such as accepted and declined at once, or a reason set when nothing was cancelled.
    0 installs
  24. ▌
    Oo Refactoring Toward Object Design · yutna bundle
    Use when restructuring working code without changing what it does, when a refactoring grew too big to finish, or when moving toward a pattern.
    0 installs
  25. ▌
    Oo Typescript Angular · yutna bundle
    Use 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.
    0 installs
  26. ▌
    Oo Encapsulating State And Behaviour · yutna bundle
    Use 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.
    0 installs
  27. ▌
    Oo Separating Presentation From Domain · yutna bundle
    Use 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.
    0 installs
  28. ▌
    Oo Choosing Composition Over Inheritance · yutna bundle
    Use when a subclass only reuses code, when a base class change breaks its subclasses, or when choosing between extending a class and wrapping it.
    0 installs
  29. ▌
    Oo Replacing Conditionals With Polymorphism · yutna bundle
    Use when the same switch or if-chain on a type or status repeats across methods, or when choosing subclasses or pattern matching for cases.
    0 installs
  30. ▌
    Oo Java · yutna bundle
    Use 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.
    0 installs
  31. ▌
    Oo Ruby · yutna bundle
    Use 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.
    0 installs
  32. ▌
    Oo Design · yutna bundle
    Use when starting a new module, feature or system in an object-oriented codebase, sizing design, or unsure which object rule applies.
    0 installs
  33. ▌
    Oo Csharp · yutna bundle
    Use when plain C# with no framework needs a record or a struct, nullable reference types, a default interface member, or async and await.
    0 installs
  34. ▌
    Oo Kotlin · yutna bundle
    Use 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.
    0 installs
  35. ▌
    Oo Python · yutna bundle
    Use 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.
    0 installs
  36. ▌
    Oo Java Swing · yutna bundle
    Use when Java Swing code updates components off the event dispatch thread, decides rules inside listeners, or backs a JTable with domain objects.
    0 installs
  37. ▌
    Oo Javascript · yutna bundle
    Use 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.
    0 installs
  38. ▌
    Oo Ruby Rails · yutna bundle
    Use when a Rails app's Active Record models gather rules, callbacks hide side effects, or a service or query object is being weighed.
    0 installs
  39. ▌
    Oo Typescript · yutna bundle
    Use 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.
    0 installs
  40. ▌
    Oo Bounding Contexts · yutna bundle
    Use when splitting a large model between teams, choosing how parts with their own models talk, or deciding which parts to build or buy.
    0 installs
  41. ▌
    Oo Choosing A Pattern · yutna bundle
    Use 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.
    0 installs
  42. ▌
    Oo Organising Modules · yutna bundle
    Use when grouping classes into packages, when packages depend on each other in a cycle, or choosing between a modular monolith and services.
    0 installs
  43. ▌
    Oo Taming Persistence · yutna bundle
    Use 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.
    0 installs
  44. ▌
    Oo Java Javafx · yutna bundle
    Use 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.
    0 installs
  45. ▌
    Oo Java Spring · yutna bundle
    Use when Java code on Spring wires beans with @Autowired or annotations, places @Transactional, or gives a JPA entity setters instead of its own rules.
    0 installs
  46. ▌
    Oo Diagnosing Coupling · yutna bundle
    Use 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.
    0 installs
  47. ▌
    Oo Layering The System · yutna bundle
    Use when choosing layered, hexagonal or clean architecture, when an inner layer imports an outer one, or a screen needs its framework in tests.
    0 installs
  48. ▌
    Oo Modeling Lifecycles · yutna bundle
    Use when deciding which status transitions are allowed, when something cancelled can still go ahead, or a closed one is reopened and edited.
    0 installs
  49. ▌
    Oo Designing Aggregates · yutna bundle
    Use when choosing what one transaction keeps consistent, when two people saving at the same time break it, or one load pulls in too much.
    0 installs
  50. ▌
    Oo Designing Interfaces · yutna bundle
    Use when an interface has methods its callers never use, when it copies public members of one type, or when picking interface or abstract base.
    0 installs
  51. ▌
    Oo Making Work Reliable · yutna bundle
    Use 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.
    0 installs
  52. ▌
    Oo Placing Domain Logic · yutna bundle
    Use when choosing a domain service, entity method or application service, when use cases repeat one check, or picking scripts or a domain model.
    0 installs
  53. ▌
    Oo Hiding Implementation · yutna bundle
    Use when many classes know how another stores or formats data, when callers must handle its internal errors, or must call its steps in order.
    0 installs
  54. ▌
    Oo Managing Shared State · yutna bundle
    Use 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.
    0 installs
  55. ▌
    Oo Designing Repositories · yutna bundle
    Use when designing a repository, when it grows a find method per screen, returns rows instead of objects, or updates single fields.
    0 installs
  56. ▌
    Oo Inverting Dependencies · yutna bundle
    Use when domain code depends on a database, framework or clock, when an object builds or looks up its collaborators, or when wiring objects.
    0 installs
  57. ▌
    Oo Csharp Aspnet · yutna bundle
    Use 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.
    0 installs
  58. ▌
    Oo Python Django · yutna bundle
    Use when a Django project's models, views or signals carry business rules, or its apps are being drawn as boundaries.
    0 installs
  59. ▌
    Oo Deciding Object Or Data · yutna bundle
    Use when deciding if something should be a class or just data, when classes are only getters and setters, or when shaping DTOs and records.
    0 installs
  60. ▌
    Oo Reviewing Object Design · yutna bundle
    Use when reviewing a pull request or a design for object-design problems, or when deciding which review findings must block a merge.
    0 installs
  61. ▌
    Oo Designing What To Record · yutna bundle
    Use when deciding what to log, measure or trace, when an incident cannot be explained from the records, or staff actions need an audit trail.
    0 installs
  62. ▌
    Oo Publishing Domain Events · yutna bundle
    Use 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.
    0 installs
  63. ▌
    Gherkin Discovery · yutna bundle
    Turn 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.
    5 installs
  64. ▌
    Gherkin Automation · yutna bundle
    Implement 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.
    5 installs
  65. ▌
    Gherkin Suite Design · yutna bundle
    Shape 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.
    7 installs
  66. ▌
    Gherkin Scenario Review · yutna bundle
    Critique 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.
    4 installs
  67. ▌
    Gherkin Scenario Writing · yutna bundle
    Write 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.
    2 installs