advent-of-craft/2024

This system is a multi-language educational platform providing exercise scaffolding and complete solutions for a series of programming challenges. It covers a wide range of domains including gift management, reindeer logistics, and encryption, implemented across Java, Kotlin, PHP, Scala, TypeScript, C\#, and Python. The repository supports both learning through incomplete code templates and verification through comprehensive test suites for each language.

A new 'Preparation' feature was added to the Christmas application, introducing logic to determine who prepares gifts based on quantity (Elves for fewer than 50 gifts, Santa otherwise), categorize gifts by recipient age (Baby, Toddler, Child, Teen), and validate toy type balance requirements. The update includes the core implementation in \Preparation.cs\, a helper extension in \Extensions.cs\, and a comprehensive set of unit tests in \PreparationTests.cs\ that verify these behaviors.

solution/day11 · high confidence

Introduced a new exercise for Day 03, implementing a 'Santa's Workshop' scenario across Java, Kotlin, PHP, Scala, and TypeScript. The feature includes a \Gift\ class that stores item details and attributes, and a \SantaWorkshopService\ that manages gift preparation. Users can create gifts with specific properties, add custom attributes, and retrieve recommended ages. The service enforces a 5 kg weight limit, throwing an error if a gift is too heavy for Santa's sleigh.

(repo-wide) · high confidence

A new Day 1 solution is introduced, featuring a SantaCommunicator that composes return messages for reindeer and detects overdue status based on configuration. The change includes the core implementation (Logger interface, SantaCommunicator class) and corresponding unit tests (SantaCommunicatorTest, TestLogger double) to verify message composition and overdue detection.

solution/day01 · high confidence

A new solution for Day 10 has been added, implementing a \Building\ class that calculates the final floor level based on a string of parentheses instructions. The logic distinguishes between standard rules (up 1, down 1) and an 'Elf' mode (up -2, down 3) triggered by the presence of an elf symbol (🧝) in the input. Test cases in \Delivery.Tests\ verify the floor calculations for various input files, including edge cases and large inputs.

solution/day10 · high confidence

Introduced the Day 11 exercise across Java, Kotlin, PHP, Scala, and TypeScript. The new exercise provides implementations for preparing gifts, categorizing gifts by age, and ensuring toy balance, along with corresponding test suites for each language.

(repo-wide) · high confidence

A new exercise titled 'Santa's Christmas List' has been added for Day 15. The implementation provides the core business logic for loading gifts into a sleigh, supported by dependency classes (Factory, Inventory, WishList) and domain models (Child, Gift, Sleigh). This feature is available in Java, Kotlin, PHP, Scala, and TypeScript, each with corresponding unit tests.

(repo-wide) · high confidence

Introduced the Day 16 exercise across Java, PHP, and TypeScript, each providing an \Elf\ model and a \TaskAssignment\/\TaskAssignmentSystem\ class. These implementations support tracking task completions, assigning tasks based on skill levels, adjusting skill levels, reassigning tasks, sorting elves by skill, and resetting skills to a baseline. The Java and TypeScript versions include an \assignTaskBasedOnAvailability\ method marked for deprecation in favor of \assignTask\.

exercise/java/day16, exercise/php/day16, exercise/ts/day16 · high confidence

New exercise files have been added for Day 18, implementing the Rock, Paper, Scissors game logic and associated test steps across Java, PHP, Python, and TypeScript. The Java implementation includes the core game classes (Choice, RockPaperScissors, Winner) and Cucumber test steps. PHP provides a FeatureContext and game class. Python includes step definitions for the game. TypeScript defines the game logic and step definitions. Each language version implements the standard rules of Rock, Paper, Scissors, allowing users to practice this specific exercise.

(repo-wide) · high confidence

Introduced the Day 19 exercise across Java, Kotlin, PHP, Scala, and TypeScript, each implementing a \SantaTravelCalculator\ that calculates total travel distance recursively. The implementations handle integer overflow for inputs greater than 32, with corresponding unit tests verifying correct distances for small inputs and overflow exceptions for large ones.

(repo-wide) · high confidence

Introduced a new interactive exercise for Day 23 that simulates a sleigh control system. The implementation, provided in Java, Kotlin, PHP, Python, Scala, and TypeScript, allows users to manage a fleet of reindeer to generate magic power, ascend, descend, and park the sleigh. The system tracks reindeer status, including rest requirements and sickness, and enforces state transitions (e.g., preventing actions before starting the system). Each language variant includes corresponding unit tests to verify the control logic.

(repo-wide) · high confidence

Added a new solution for Day 7, including the Gradle wrapper scripts (gradlew, gradlew.bat) and properties to support building the project. The Kotlin source introduces a Gift data class with a Status enum (Producing, Produced) and a Workshop class that manages a list of gifts, allowing users to add gifts and mark them as completed. Corresponding Kotest-based tests verify that completing a gift updates its status to Produced and that completing a non-existent gift returns null.

solution/day07 · high confidence

New exercise files have been added for 'day 22' across five languages (Java, Kotlin, PHP, Scala, and TypeScript). Each implementation provides an \EID\ class or object with a \parse\ method that parses a string into a structured EID (containing sex, year, and serial number) and validates a checksum key. The diff also includes supporting types (e.g., \ParsingError\/\ParsingException\), helper classes for each component, and property-based tests to verify that valid EIDs round-trip correctly and invalid ones are rejected.

(repo-wide) · high confidence

Introduces a new EID (Electronic ID) parsing system that validates and constructs EID objects from string representations. The implementation includes classes for Sex, Year, and SerialNumber components, along with a builder pattern for construction. The parser validates the sex code, year (0-99), serial number (1-999), and a control key checksum. A round-trip test ensures that parsing a formatted EID string produces an equivalent EID object.

solution/day17 · high confidence

Added an EID validation class that checks the format, serial number, and key of an ID string. The implementation ensures that the serial number is greater than zero and that the calculated key matches the expected value, providing a robust way to verify ID validity.

solution/day05 · high confidence

Introduced the FizzBuzz exercise across Java, Kotlin, PHP, Scala, and TypeScript. Each language now includes a core implementation and corresponding tests that validate converting numbers between 1 and 100 into 'Fizz', 'Buzz', or 'FizzBuzz' strings, while correctly handling out-of-range inputs.

(repo-wide) · high confidence

Introduces a new ASP.NET Core web application that exposes endpoints for creating and retrieving reindeer records, along with a corresponding test suite that validates the API contract. The implementation includes the \Program.cs\ entry point, domain models (Reindeer, ReindeerService), and configuration files, while the test project verifies GET and POST behaviors using verified snapshots.

solution/day20 · high confidence

Added a new solution for day 18 implementing the Rock, Paper, Scissors, Lizard, Spock game logic. The change includes the core game engine in \src/rockPaperScissorsLizardSpock.ts\ which handles all 10 winning combinations and draw conditions, along with Cucumber feature files and step definitions to verify the game's behavior through automated tests.

_solution/day18, solution/day18/features/step\definitions · high confidence

Introduced a new solution for day 13 that implements a shopping cart system capable of processing various special offers. The update adds model classes for products, receipts, and discounts, along with a \ShoppingSleigh\ that calculates prices and applies specific discount types, including 'buy X get Y free', '10% off', and fixed-amount bundle pricing (e.g., '2 for $1.60'). A corresponding test suite verifies the correct application of these discounts to the final receipt.

solution/day13 · high confidence

Users can now complete the Day 25 exercise, which implements a 'Time Capsule' application across Java, Kotlin, PHP, Scala, and TypeScript. This feature allows users to save a message to an HTML file, which is then opened in the default web browser. The application reads any previously saved message and displays it upon launch, providing a way to leave and retrieve notes for the future.

(repo-wide) · high confidence

Introduced new mappers and DTOs to transform raw database records (X5T78) into structured Child objects with nested Address details. This change adds the necessary model classes, mapping logic, and corresponding unit tests across five language implementations (Java, Kotlin, PHP, Scala, TypeScript) to support the Day 14 exercise.

(repo-wide) · high confidence

Introduced new 'day 0' exercise files across four languages (Java, PHP, Scala, TypeScript) that implement an AES-256-CBC encryption/decryption utility. Each implementation accepts a Base64-encoded key and IV, encrypts plaintext to Base64, and decrypts back to the original string. Tests verify that encrypting and then decrypting a string returns the original input, and Java/Scala include specific string assertions. A shared test resource file (EncryptedEmail.txt) is also added.

(repo-wide) · high confidence

New exercise scaffolding for day 04 has been added across Java, Kotlin, PHP, Scala, and TypeScript. Each language now includes the core domain classes and interfaces (Email, EmailService, ReindeerFeeder, Schedule, ScheduleService, and Routine) that define the structure for the daily routine exercise, along with corresponding test files to guide implementation.

(repo-wide) · high confidence

New exercise files were added for Java, Kotlin, PHP, and TypeScript, each implementing a 'Workshop' class that manages a collection of 'Gift' objects. The core behavior allows users to add gifts and then complete a gift by name, which updates its status from 'Producing' to 'Produced' (or returns empty/null if not found). Tests verify that completing a gift updates its status and that non-existent gifts return empty results.

(repo-wide) · high confidence

New model classes and a service for evaluating gift requests are added across Java, Kotlin, PHP, Scala, and TypeScript. The \SantaService\ implements a rule that approves a request only if the child's behavior is 'nice' and the gift is feasible. Corresponding test suites verify that requests are approved for nice children with feasible gifts, and denied for naughty children or infeasible gifts.

(repo-wide) · high confidence

Introduced the Day 10 exercise across Kotlin, PHP, Scala, and TypeScript implementations. The new \Building\ class in each language provides a \whichFloor\ method that processes instruction strings to calculate a floor number. Test suites and corresponding resource files have been added for each language to verify the logic against expected floor values.

(repo-wide) · high confidence

Introduced the 'day 12' exercise across Java, Kotlin, PHP, and TypeScript, implementing a Santa class that distributes toys to children based on their behavior. The logic assigns the third choice for 'naughty' children, the second choice for 'nice' children, and the first choice for 'very nice' children, with tests verifying these outcomes.

(repo-wide) · high confidence

The day 13 exercise introduces a new set of model classes and test scaffolding across Java, Kotlin, Scala, and PHP implementations. The core domain model includes Product, ProductQuantity, Receipt, and Discount classes, along with an Offer class to represent special offers. The SantaMarketCatalog interface and its FakeCatalog test double are provided for each language. The ChristmasElf class orchestrates the checkout process, and the ShoppingSleigh class handles the application of special offers (such as 'three for two', 'ten percent discount', 'two for amount', and 'five for amount' promotions) to generate a final Receipt containing line items and applied discounts. Corresponding unit tests verify the correct calculation of totals and discounts for various scenarios.

(repo-wide) · high confidence

New exercise files are added for day 20, providing starter code for a reindeer management API across multiple languages. The Java implementation uses Spring Boot with a ReindeerService, while the Kotlin version uses Ktor. The PHP implementation uses a simple controller and service, and the TypeScript version uses Express. Each language provides the core service logic and controller endpoints for creating and retrieving reindeer, along with corresponding test files to verify the behavior.

(repo-wide) · high confidence

New exercise files for day 06 have been added across Java, PHP, Scala, and TypeScript, each implementing the ElfWorkshop class with methods to add and complete tasks. Corresponding test files have also been added for Java and Scala to verify the new functionality.

(repo-wide) · high confidence

Introduced a new email encryption module that provides AES-based encryption and decryption for email content. The implementation includes an \Encryption\ class that uses a configurable key and initialization vector, along with supporting files for configuration, file utilities, and a comprehensive test suite verifying that encrypted emails can be successfully decrypted back to their original form.

solution/day00 · high confidence

Added C\# exercise projects for days 00 through 10, each containing a solution file, domain/service classes, and corresponding unit tests. The new code introduces encryption logic (day 00), communication and scheduling routines (days 01–04), game logic (day 02), gift preparation (day 03), task management (days 05–06), workshop state management (day 07), toy production with repository abstraction (day 08), gift wish evaluation (day 09), and delivery validation (day 10).

exercise · high confidence

Introduced a new C\# solution for Day 24, including the core \Delete\ use-case implementation and a comprehensive test suite. The solution is configured via \.tcr\ files for the \dotnet\ toolchain, and the \Delivery.sln\ file defines the project structure. The test suite includes unit tests for creating toys with valid and invalid stock levels, as well as use-case tests verifying the deletion flow, stock updates, and event raising behavior using an in-memory repository double.

solution/day24 · high confidence

Introduced the Day 15 solution, which implements a gift-loading system for Santa's sleigh. The change includes two distinct implementations: a standard object-oriented approach in the \SantaChristmasList.Operations\ project, and a functional approach using the \LanguageExt\ library's \Either\ type in the \SantaChristmasList.Operations.Monad\ project. Both implementations handle the logic for identifying gifts, checking manufacturing status, and managing inventory, accompanied by corresponding unit tests for each approach.

solution/day15 · high confidence

Introduced a new solution for Day 16, featuring a \TaskAssignmentSystem\ that manages a collection of \Elf\ objects. The system supports assigning tasks based on skill levels, reassigning skills between elves, tracking completed tasks, and sorting elves by skill. A corresponding test suite validates these behaviors, including edge cases like negative skill levels and unsorted initial states.

solution/day16 · high confidence

New exercise files were added for day 21, each implementing a TourCalculator that processes a list of tour steps. The Java and TypeScript versions return an Either type (left for error, right for success), while the PHP version returns a string or error message. All three implementations sort steps by time, calculate total delivery time, and format the output with individual step details and the total duration in HH:MM:SS format.

exercise/java/day21, exercise/php/day21, exercise/ts/day21 · high confidence

Introduced a new solution for Day 21, implementing a tour calculator that processes a sequence of scheduled stops. The update includes the core domain model (Step, SantaError), a legacy TourCalculator class, a new StepsTextFormatter for output formatting, and corresponding unit tests using FsCheck to verify that the new implementation matches the previous behavior.

solution/day21 · high confidence

A new solution for Day 23 has been introduced, implementing a console-based application that controls a magical sleigh. The system allows users to start the sleigh, then issue commands to ascend, descend, park, or stop the vehicle. The application manages the sleigh's state transitions (Parked, Flying, Hovering) and handles power requirements for the reindeer, displaying status updates and available commands via the console.

solution/day23 · high confidence

Introduced a new interactive Time Capsule application for Day 25. Users can enter a message that is saved to an HTML file, which is then automatically opened in the default browser. The app also displays any previously saved message from the past.

solution/day25 · high confidence

A new solution for Day 3 has been introduced, featuring a Gift class that stores toy details and a SantaWorkshopService that manages gift preparation. The service enforces a 5 kg weight limit, throwing an error for heavier items, and includes tests verifying gift creation, attribute retrieval, and weight validation.

solution/day03 · high confidence

Introduced a new 'Morning Routine' application that executes a sequence of tasks: organizing the day's schedule, feeding the reindeers, reading new emails, and continuing the routine. The solution includes the core \Routine\ class and supporting models (\Schedule\, \Email\) and service interfaces (\IEmailService\, \IReindeerFeeder\, \IScheduleService\). Additionally, unit tests were added using both manual fakes and FakeItEasy mocks to verify the execution order and interactions of the routine's components.

solution/day04 · high confidence

Introduced a new solution for Day 6, including an ElfWorkshop class that manages a list of tasks, allowing users to add and complete tasks while filtering out empty entries. The change also includes a Jest configuration for TypeScript testing, a TypeScript configuration file, and a test suite that verifies the task addition and completion functionality.

solution/day06 · high confidence

Introduced the domain model for Day 8, including the Toy entity with an assignment workflow (UNASSIGNED → IN\_PRODUCTION), a repository interface, and the ToyProductionService that handles assigning toys to elves. A test suite and in-memory repository double were also added to verify the assignment logic.

solution/day08 · high confidence

Introduced a new solution for Day 9, implementing a Santa service that evaluates gift requests based on a child's behavior and gift feasibility. The implementation includes domain models for Child, GiftRequest, and Priority, along with a SantaService that approves requests only for 'nice' children with feasible gifts. A test suite verifies this logic, and supporting configuration files (jest, tsconfig) are added to enable the solution.

solution/day09 · high confidence

Introduced a new solution for Day 22 that parses and validates Electronic ID (EID) strings. The implementation includes classes for parsing sex, year, and serial number components, along with a key validation check. A corresponding test suite verifies that valid EIDs round-trip correctly and that mutated or invalid inputs are properly rejected.

solution/day22 · high confidence

Added a new FizzBuzz solution for Day 2, including the Kotlin implementation in \games/FizzBuzz.kt\ and corresponding unit and property-based tests in \FizzBuzzTests.kt\ and \FizzBuzzProperties.kt\. The solution uses Arrow's \Option\ type to handle valid and out-of-range inputs, with a configurable mapping of divisors to strings. The directory also includes standard Gradle wrapper files (\gradlew\, \gradlew.bat\, and \gradle-wrapper.properties\) to support building and testing the solution.

solution/day02 · high confidence

Introduced a new solution for Day 19, featuring a \SantaTravelCalculator\ that computes total travel distance using four distinct algorithms: a recursive approach, an iterative loop, a LINQ-based aggregation, and a bitwise operation. The change includes the core calculator implementation, a corresponding unit test suite (\CalculatorTests\) to verify correctness across various reindeer counts, and a benchmarking project (\SantaTravelBenchmark\) to evaluate the performance of each algorithm.

solution/day19 · high confidence

New exercise files were added for Java, Kotlin, PHP, Scala, and TypeScript, each implementing a \SantaCommunicator\ class that calculates the number of days before Christmas and determines if a reindeer is overdue. Each language also includes a corresponding \Logger\ interface and a \TestLogger\ double for testing purposes.

(repo-wide) · high confidence

Introduced a new mapping layer for the 'Children' domain in solution/day14, converting raw X5T78 database records into structured Child DTOs. The change includes the Child and Address value objects, a ChildMapper using Mapperly attributes to map fields like name, birth details, and address, and corresponding unit tests to verify the transformation for both boy and girl records.

solution/day14 · high confidence

Added the complete domain and use-case implementation for the 'day 24' exercise in C\#, Java, Kotlin, PHP, and Scala. Each language module introduces a \Toy\ aggregate that extends an \EventSourcedAggregate\ base class, utilizing a \RegisteredRoutes\ mechanism to dispatch domain events like \ToyCreatedEvent\ and \StockReducedEvent\. The implementation includes a \ToyDeliveryUseCase\ that handles the logic for delivering toys and reducing stock, supported by corresponding repository interfaces and in-memory test doubles for verification.

(repo-wide) · high confidence

Introduced new PHP classes and enums across various daily exercise directories (day 9, 11, 13, 14, 20, 23, 24). These include enumerations for gift behavior, priority, toy types, product units, special offers, gender, reindeer colors, sex, amplifier types, sleigh actions, and engine status. Additionally, new domain classes were added for event sourcing, including an Event class, an abstract EventSourcedAggregate base class, and a Toy aggregate with stock management capabilities.

php · medium confidence

The control-system module now includes a comprehensive set of exercise and solution files for the Advent of Code 2024 challenges. This update adds Java and Kotlin implementations for days 0, 1, 4, 6, 7, 9, 10, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, and 24. The changes include new domain models, controllers, services, and utility classes across both Java and Kotlin, covering a wide range of problem-solving scenarios from email encryption and gift management to reindeer logistics and stock reduction events.

control-system · high confidence

Added new exercise days (04, 07, 09, 12, 13, 14, 15, 16, 18, 20, 21, 22, 24) containing Scala source files. These introduce domain models and logic for various scenarios: email and schedule structures (day 04), a workshop gift production system (day 07), child and gift request models (day 09), a Santa toy selection system (day 12), a market discount and receipt model (day 13), child and address DTOs (day 14), sleigh gift operations (day 15), elf task assignment and skill management (day 16), a rock-paper-scissors game (day 18), a reindeer management service (day 20), a tour calculator (day 21), an ID parsing and validation system (day 22), and domain events for stock and toy creation (day 24).

day00 · high confidence

New Python exercise files were added for days 18, 20, and 24. Day 18 introduces a Rock-Paper-Scissors game logic. Day 20 adds a Django model for a Reindeer entity. Day 24 introduces core domain classes for an event-sourced aggregate system, including an Aggregate base class, an EventSourcedAggregate implementation, and a Toy domain model that manages stock via events.

python · high confidence

New domain models and services for managing toy production states (UNASSIGNED, IN\_PRODUCTION, COMPLETED) were added across Java, Kotlin, PHP, Scala, and TypeScript implementations. The change introduces a ToyProductionService that assigns toys to elves by transitioning them from UNASSIGNED to IN\_PRODUCTION, supported by a ToyRepository interface and corresponding test doubles.

(repo-wide) · high confidence

Added a new solution for day 12 that implements a gift distribution system. The \Santa\ class uses a \ChildrenRepository\ to look up children and determine which toy to select from their \Wishlist\ based on their \Behavior\ (NAUGHTY, NICE, or VERY\_NICE). The \Child\ class enforces that each child has exactly three toy wishes, and the \Wishlist\ stores these preferences. Tests verify that naughty children receive their third choice, nice children receive their second, and very nice children receive their first choice.

solution/day12 · high confidence

Added Cucumber-based test suites for the Rock Paper Scissors exercise; Added encryption tests for email functionality; Added initial test scaffolding for Day 05 exercises; Added initial test scaffolding for Day 17; Added test coverage for day 10; Added test suites for the Day 16 Task Assignment System; Added tests for Santa's gift selection logic; Added tests for the ElfWorkshop exercise; Added tests for the gift completion workflow.

All C\# exercise projects have been updated to target .NET 8.0, enabling modern C\# features such as implicit usings and nullable reference types. Test projects now reference xUnit 2.9.2, Microsoft.NET.Test.Sdk 17.11.1, and FluentAssertions 6.12.1. Some exercises, such as RockPaperScissorsGame, now include SpecFlow for BDD testing, while others like Children and Reindeer.Web introduce new dependencies like Riok.Mapperly and Swashbuckle.AspNetCore.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 53 (+3.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 76 → 92 (+15.9)
• Architecture 97 → 89 (-7.5)
• Maturity 45 → 45 (+0.0)
• Readiness 38 → 48 (+10.0)
• Security 78 → 66 (-11.3)
• Domain Modelling 89 → 91 (+2.9)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 59 → 59 (+0.0)

• Dependency hygiene not measured — no packages were read
• High CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day11/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day18/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day20/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day11/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day18/package-lock.json)
• High CVE: [GHSA redacted] (exercise/python/day11/requirements.txt)
• High CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• High CVE: [GHSA redacted] (exercise/ts/day18/package-lock.json)
• High CVE: [GHSA redacted] (exercise/php/day20/composer.lock)
• High CVE: [GHSA redacted] (exercise/php/day00/composer.lock)
• LLM evaluation failed
• Low CVE: [GHSA redacted] (exercise/php/day18/composer.lock)
• Low CVE: [GHSA redacted] (exercise/ts/day00/package-lock.json)
• Low CVE: [GHSA redacted] (exercise/ts/day02/package-lock.json)
• Low CVE: [GHSA redacted] (exercise/ts/day11/package-lock.json)
• …and 23 more

• Building.whichFloor (cognitive 16) (exercise/kotlin/day10/src/main/kotlin/delivery/Building.kt)
• Building.whichFloor (cognitive 18) (exercise/java/day10/src/main/java/delivery/Building.java)
• Building.whichFloor (cognitive 18) (exercise/scala/day10/src/main/scala/delivery/Building.scala)
• Building.whichFloor (cognitive 20) (exercise/php/day10/src/Delivery/Building.php)
• Documentation: no installation or build instructions
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview
• Documentation: no project overview (README.md)
• Duplicated block (11–12 lines × 2) (exercise/java/day13/src/main/java/santamarket/model/ShoppingSleigh.java)
• Duplicated block (13 lines × 2) (exercise/java/day13/src/main/java/santamarket/model/ChristmasElf.java)
• Duplicated block (14 lines × 2) (exercise/java/day23/src/main/java/external/stable/MagicStable.java)
• Duplicated block (15 lines × 2) (exercise/java/day23/src/main/java/external/deer/Reindeer.java)
• Duplicated block (18 lines × 2) (exercise/java/day03/src/main/java/preparation/SantaWorkshopService.java)
• Duplicated block (18 lines × 3) (exercise/java/day22/src/main/java/eid/StringExtensions.java)
• Duplicated block (21 lines × 2) (solution/day17/src/main/java/eid/SerialNumber.java)
• Duplicated block (21 lines × 2) (solution/day17/src/main/java/eid/Year.java)
• Duplicated block (29 lines × 2) (exercise/java/day03/src/main/java/preparation/Gift.java)
• Duplicated block (34 lines × 2) (exercise/java/day13/src/main/java/santamarket/model/Product.java)
• Duplicated block (39 lines × 2) (exercise/java/day13/src/main/java/santamarket/model/Discount.java)
• Duplicated block (3–61 lines × 4) (exercise/java/day22/src/main/java/eid/EID.java)
• …and 67 more

• Unchanged — 2 HTTP endpoints

• Containers 0 added · 0 removed · contexts 27 added · 0 removed · edges 5 added · 0 removed

• Delivery.Domain
• Santamarket
• day04
• day06
• day07
• day09
• day12
• day13
• day14
• day15
• day16
• day18
• day20
• day21
• day22
• day23
• day24
• delivery
• eid
• email
• …and 7 more

• day12 → day09 (coupling)
• day14 → day09 (coupling)
• day15 → day09 (coupling)
• day18 → rock-paper-scissors-lizard-spock
• day23 → day20 (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

advent-of-craft/2024 was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.