exercism/vbnet

This system is the Visual Basic track for the Exercism programming exercise platform, providing a curated set of coding challenges for learners. It manages the lifecycle of these exercises by generating stubs, test suites, and example solutions from canonical data, while enforcing consistent code styles and modern .NET 10 tooling. The repository serves as the infrastructure for users to practice and verify their Visual Basic implementations against a comprehensive suite of unit tests.

24 changes.

This period focused on significantly expanding the Visual Basic track by adding numerous new exercises, example solutions, and test generators. The work also involved modernizing the track's infrastructure by upgrading all exercises to .NET 10 and migrating the testing framework to xUnit v3.

12 changes.

This period focused on populating the Visual Basic track with a wide variety of new practice exercises, including algorithms, cryptography, and logic puzzles. Each addition established a consistent project structure targeting .NET 10 and utilizing the xUnit v3 testing framework.

7 changes.

This period focused on expanding the Visual Basic track by adding new practice exercises such as Eliud's Eggs, Camicia, Prism, and Pascal's Triangle. It also introduced automated generator tooling to scaffold exercises and updated the project's solution format to .slnx for better tooling compatibility.

This change introduces the 'Say' practice exercise, providing a stub implementation in \Say.vb\ and a corresponding test suite in \SayTests.vb\. The tests define the expected behavior for the \InEnglish\ function, covering conversions for numbers from zero up to nine hundred eighty-seven billion, as well as validation for out-of-range inputs (negative numbers and values exceeding 999,999,999,999). The exercise is configured with an \.editorconfig\ for consistent coding style and depends on \Exercism.Tests.xunit.v3\ along with \xunit.v3\ for running the tests.

exercises/practice/say · high confidence

A new practice exercise has been added for the Visual Basic track, requiring users to simulate the 'Camicia' card game (based on Beggar-My-Neighbour). The solution must process two player decks, handle payment card penalties (Jack through Ace), and determine if the game finishes or enters an infinite loop, returning the final status, total tricks, and cards played. The entry includes the problem instructions, a stub implementation, a full example solution, and a comprehensive test suite covering various game scenarios.

exercises/practice/camicia · high confidence

A new Diffie-Hellman key exchange exercise has been added to the Visual Basic track. The change introduces the \DiffieHellman.vb\ stub file containing three unimplemented functions (\PrivateKey\, \PublicKey\, and \Secret\) using \System.Numerics.BigInteger\, along with \DiffieHellmanTests.vb\ which includes one active test for private key range validation and several skipped tests for public key generation, secret calculation, and full key exchange. The exercise is configured with an \.editorconfig\ for consistent coding styles and depends on \Exercism.Tests.xunit.v3\ (version 0.1.0-beta1) and \xunit.v3\ (version 3.2.2) for the test framework.

(repo-wide) · high confidence

This change introduces the Diffie-Hellman key exchange exercise to the Visual Basic track. It includes the solution example (\Example.vb\) implementing private key generation, public key calculation, and secret derivation using \System.Numerics.BigInteger\, along with the test generator template (\Generator.tpl\), configuration (\config.json\), and test metadata (\tests.toml\) to support learners practicing this cryptographic protocol.

exercises/practice/diffie-hellman/.meta · high confidence

The ETL (Extract-Transform-Load) exercise is now available for Visual Basic, providing a starter project with an \Etl.vb\ stub implementing the \Transform\ function and a corresponding \EtlTests.vb\ test file. The test suite includes a passing example for single-letter mapping and several skipped tests covering multiple letters, scores, and full alphabet mappings to guide implementation. The project is configured with an \.editorconfig\ for consistent coding styles and targets .NET 10.0, utilizing the \Exercism.Tests.xunit.v3\ framework along with \xunit.v3\ and \Microsoft.NET.Test.Sdk\ for testing.

(repo-wide) · high confidence

Introduces the Eliud's Eggs practice exercise for the Visual Basic track, enabling users to solve the problem of counting set bits in a binary representation. The addition includes the exercise configuration, a template for generating test cases, and an example solution that implements the bit-counting logic.

exercises/practice/eliuds-eggs/.meta · high confidence

A new practice exercise for counting eggs (population count) has been added to the Visual Basic track. This includes the \EliudsEggs.vb\ stub file with the \EggCount\ function signature, the \EliudsEggsTests.vb\ test suite covering zero, one, four, and thirteen egg scenarios, and an \.editorconfig\ file to enforce consistent coding styles and naming conventions for the project.

exercises/practice/eliuds-eggs · high confidence

A new practice exercise for Pascal's Triangle has been added to the Visual Basic track. Users can now implement the \Calculate\ function in \PascalsTriangle.vb\ to generate the first N rows of the triangle, guided by the provided instructions and introduction documentation. The exercise includes a test suite (\PascalsTriangleTests.vb\) covering cases from zero to ten rows, an example solution, and the necessary project configuration and dependency locks to run the tests.

exercises/practice/pascals-triangle · high confidence

The Prism exercise is now available for Visual Basic, allowing users to implement a laser path prediction algorithm that calculates the sequence of crystal hits as a beam refracts through a series of prisms. The change includes the exercise stub (\Prism.vb\) with the \FindSequence\ method signature, a comprehensive test suite (\PrismTests.vb\) covering scenarios from zero prisms to complex multi-prism floating-point precision cases, and an example solution (\.meta/Example.vb\) demonstrating the geometric ray-casting logic. Configuration files (\config.json\, \tests.toml\) and documentation (\instructions.md\, \introduction.md\) are also added to support the new track.

exercises/practice/prism · high confidence

A new Saddle Points exercise has been added for the Visual Basic track. The change introduces the \SaddlePoints.vb\ stub file containing the \Calculate\ function signature, along with \SaddlePointsTests.vb\ which includes test cases for identifying single and multiple saddle points, handling empty matrices, and processing non-square matrices. An \.editorconfig\ file is also added to enforce consistent coding styles for the exercise, and the project dependencies are configured to use \xunit.v3\ and \Exercism.Tests.xunit.v3\.

(repo-wide) · high confidence

A new practice exercise has been added for the Visual Basic track, requiring users to implement musical scale generation. The \ScaleGenerator\ module exposes two methods: \Chromatic\, which returns the 12-note chromatic scale starting from a given tonic (using sharps or flats based on the key signature), and \Interval\, which generates diatonic or other scales based on a pattern of intervals (major, minor, augmented). The entry includes the problem instructions, a stub implementation, a test suite covering various modes (Dorian, Mixolydian, etc.) and scale types, and the necessary configuration files.

(repo-wide) · high confidence

This change introduces the Secret Handshake practice exercise for the .NET track, providing the initial project structure for .NET 10. It includes a stub implementation in \SecretHandshake.vb\ that throws \NotImplementedException\, a test suite in \SecretHandshakeTests.vb\ using xUnit v3 (with most tests skipped by default), and an \.editorconfig\ file to enforce consistent coding styles and naming conventions for Visual Basic files.

exercises/practice/secret-handshake · high confidence

A new practice exercise for the Sieve of Eratosthenes has been added to the Visual Basic track. This includes the example solution, test generator template, configuration, and test data, allowing users to implement an algorithm to find all prime numbers up to a given limit.

exercises/practice/sieve/.meta · high confidence

The 'Twelve Days of Christmas' exercise is now available for Visual Basic. This addition includes the example solution (Example.vb), which implements the logic to recite individual verses or a range of verses, along with the corresponding test generator template (Generator.tpl), configuration (config.json), and test case definitions (tests.toml) to guide users in solving the problem.

exercises/practice/twelve-days/.meta · high confidence

This change introduces the configuration files, test definitions, and an example solution for the Hamming distance exercise in the VB.NET track. It provides the necessary metadata (config.json), test case descriptions (tests.toml), a template for generating tests (Generator.tpl), and a reference implementation (Example.vb) that calculates the distance between two DNA strands, including validation that strands are of equal length.

exercises/practice/anagram/.meta, exercises/practice/crypto-square/.meta, exercises/practice/hamming/.meta · high confidence

The VB.NET track now includes the Pythagorean Triplet exercise, allowing users to solve the problem of finding all triplets (a, b, c) such that a + b + c equals a given integer N. This addition includes the exercise configuration, a template for generating tests, and an example solution that uses an iterator to efficiently yield matching triplets.

exercises/practice/pythagorean-triplet/.meta · high confidence

The VB.NET track now includes the 'Meetup' exercise, allowing users to calculate specific dates (e.g., the third Monday of a month or the 'teenth' Tuesday) based on a given month and year. This change adds the example solution (\Example.vb\), which implements the \Meetup\ class and \Schedule\ enum using a strategy pattern with specific schedulers for first/second/third/fourth/last weeks and the teenth week. It also includes the test generator template (\Generator.tpl\) and configuration files (\config.json\, \tests.toml\) to support the exercise within the track's tooling.

(repo-wide) · high confidence

The phone-number exercise now includes a Visual Basic .NET solution that cleans and validates phone numbers. The implementation strips non-digit characters, handles optional leading '1' for 11-digit numbers, and enforces North American Numbering Plan rules (area and exchange codes must start with 2-9). Invalid inputs throw ArgumentException. The exercise metadata, test generator, and test cases have been added to support this track.

exercises/practice/phone-number/.meta · high confidence

A new Visual Basic practice exercise for the 'Meetup' problem has been added, providing the initial \Meetup\ class and \ScheduleType\ enum for users to implement. The accompanying test suite uses xUnit v3 and targets .NET 10, with most tests initially skipped to guide users through the implementation. An \.editorconfig\ file is also included to enforce consistent coding styles and naming conventions for Visual Basic files in this exercise.

exercises/practice/meetup · high confidence

The Matching Brackets exercise now includes a Visual Basic implementation. An example solution (Example.vb) is provided that uses a stack to validate matching brackets and braces, along with a generator template (Generator.tpl) to create the corresponding test suite. Configuration files (config.json, tests.toml) are added to define the exercise structure and test cases for the Visual Basic track.

exercises/practice/matching-brackets/.meta · high confidence

This change introduces the Visual Basic track support for the Affine Cipher exercise. It adds the canonical example solution (Example.vb) which implements the Encode and Decode functions, including logic for character filtering, modular arithmetic, and input validation (throwing ArgumentException if 'a' is not coprime to 26). It also includes the test generator template (Generator.tpl) to produce VB.NET test files, along with the exercise configuration (config.json) and test data (tests.toml) required for the track.

exercises/practice/affine-cipher/.meta, exercises/practice/beer-song/.meta, exercises/practice/bob/.meta · high confidence

This change introduces the Visual Basic track support for the perfect-numbers exercise. It adds an example implementation (Example.vb) that classifies numbers as Perfect, Abundant, or Deficient, along with a test generator template (Generator.tpl) and metadata files (config.json, tests.toml) to define the test cases and exercise structure.

exercises/practice/perfect-numbers/.meta · high confidence

This change introduces the Visual Basic track support for the Collatz Conjecture exercise. It adds an example solution (Example.vb) that implements the step-counting logic, including validation that throws an ArgumentOutOfRangeException for non-positive inputs. It also includes a test generator template (Generator.tpl) to create test cases based on the problem specifications, and updates the configuration (config.json) and test metadata (tests.toml) to define the exercise files, authors, and specific test cases (such as handling zero and negative values).

(repo-wide) · high confidence

The grep exercise is now available for Visual Basic, providing a stub implementation in Grep.vb and a comprehensive test suite in GrepTests.vb. The tests cover pattern matching across single and multiple files, supporting flags for line numbers (-n), case insensitivity (-i), file names only (-l), exact line matches (-x), and inverted matches (-v). The project targets .NET 10 and utilizes the xunit.v3 framework (version 3.2.2) along with Exercism.Tests.xunit.v3 for testing infrastructure.

exercises/practice/grep · high confidence

A new Visual Basic track for the Prime Factors exercise has been added, providing the starter code in \PrimeFactors.vb\ and a corresponding test suite in \PrimeFactorsTests.vb\. The tests are pre-configured with xUnit v3 and the \Exercism.Tests.xunit.v3\ framework, targeting .NET 10, and include a comprehensive set of cases ranging from prime numbers to large composite numbers. An \.editorconfig\ file is also included to enforce consistent coding styles and naming conventions for Visual Basic projects.

exercises/practice/prime-factors, exercises/practice/resistor-color-trio · high confidence

A new Visual Basic track for the Affine Cipher exercise has been added, providing the starter code (\AffineCipher.vb\) with stubs for \Encode\ and \Decode\ functions, along with a comprehensive test suite (\AffineCipherTests.vb\) covering encoding/decoding logic, edge cases like non-coprime keys, and input formatting. The setup includes an \.editorconfig\ file to enforce consistent coding styles and a \packages.lock.json\ pinning the project to .NET 10.0 with xUnit v3 and the \Exercism.Tests.xunit.v3\ test framework.

exercises/practice/affine-cipher · high confidence

The Zebra Puzzle practice exercise is now available, providing the initial Visual Basic project structure. This includes the \ZebraPuzzle.vb\ stub with \DrinksWater\ and \OwnsZebra\ functions, a corresponding test file \ZebraPuzzleTests.vb\ with one active test and one skipped test, and an \.editorconfig\ to enforce consistent coding styles. The project targets .NET 10.0 and references \Exercism.Tests.xunit.v3\ along with xUnit v3 for running the tests.

exercises/practice/zebra-puzzle · high confidence

The reverse-string exercise now includes a VB.NET example implementation located in .meta/Example.vb, which correctly handles string reversal including wide characters and grapheme clusters. This is accompanied by updated metadata in config.json (defining file paths and authors), a test template in Generator.tpl, and a test configuration in tests.toml that maps specific test cases like 'wide characters' and 'grapheme clusters'.

(repo-wide) · high confidence

The Accumulate exercise now includes a VB.NET example implementation (Example.vb) and a test generator template (Generator.tpl) within the .meta directory. This enables users to view a reference solution and allows the test suite to be generated from the canonical data, ensuring the tests align with the problem specifications.

exercises/practice/accumulate/.meta · high confidence

A new Visual Basic implementation for the Resistor Color exercise has been added, including the source file (ResistorColor.vb) with stub methods for ColorCode and Colors, the corresponding test suite (ResistorColorTests.vb) using xUnit v3, and an .editorconfig file to enforce consistent coding styles. The project is configured for .NET 10.0 and relies on the Exercism.Tests.xunit.v3 package.

exercises/practice/resistor-color · high confidence

This change introduces the Visual Basic track support for the Leap exercise. It adds the example solution file (Example.vb) implementing the IsLeapYear logic, a generator template (Generator.tpl) for creating test classes, and configuration files (config.json, tests.toml) that define the exercise metadata, file structure, and specific test cases for leap year determination.

exercises/practice/leap/.meta · high confidence

The Allergies exercise now includes a Visual Basic implementation stub (Allergies.vb) and a corresponding test file (AllergiesTests.vb) that define the expected API for checking allergies based on a score. The test suite covers scenarios for various allergens (eggs, peanuts, shellfish, strawberries, tomatoes, chocolate, pollen) and includes an .editorconfig file to enforce consistent coding styles and naming conventions for Visual Basic files in this exercise.

exercises/practice/allergies, exercises/practice/two-fer · high confidence

The Anagram exercise now provides a Visual Basic stub and a complete test suite targeting .NET 10, utilizing the xUnit v3 testing framework (version 3.2.2) and the Exercism.Tests.xunit.v3 adapter. The included tests cover core anagram logic, including case-insensitive matching, handling of Unicode characters, and ensuring words are not considered anagrams of themselves, while an .editorconfig file enforces consistent coding styles for the project.

exercises/practice/anagram, exercises/practice/bob · high confidence

The .meta directory for the Hello World exercise now includes the configuration file (config.json), an example solution (Example.vb), a test generator template (Generator.tpl), and test metadata (tests.toml). This provides the necessary metadata and reference implementation for the exercise, including author/contributor information, file mappings, and the standard "Say Hi!" test case.

exercises/practice/hello-world/.meta · high confidence

The Hamming exercise now includes a Visual Basic implementation stub (Hamming.vb) and a corresponding test suite (HammingTests.vb). The stub provides a Distance function that throws NotImplementedException, requiring users to implement the logic. The test suite covers scenarios such as empty strands, identical and different single-letter strands, long strands, and validation for mismatched strand lengths and empty inputs. The project is configured with an .editorconfig for consistent coding styles and targets .NET 10.0, utilizing xunit v3 for testing.

exercises/practice/hamming · high confidence

The Matching Brackets exercise now includes a Visual Basic track, providing students with a starter project that includes the \MatchingBrackets.vb\ stub file, a comprehensive test suite using xUnit v3, and an \.editorconfig\ for consistent code formatting. The test suite covers various bracket matching scenarios, including nested, paired, and invalid structures, with most tests initially skipped to guide the learner through the implementation process.

exercises/practice/matching-brackets · high confidence

This change introduces the initial project structure for the High Scores exercise, including a stub implementation in HighScores.vb that throws NotImplementedException for all required methods (Scores, Latest, PersonalBest, PersonalTopThree), a corresponding test file HighScoresTests.vb with the full suite of unit tests (most skipped by default), and an .editorconfig file to enforce consistent coding styles. It also adds a packages.lock.json file pinning the test dependencies to .NET 10.0, specifically Exercism.Tests.xunit.v3, xunit.v3, and Microsoft.NET.Test.Sdk.

exercises/practice/accumulate, exercises/practice/high-scores · high confidence

Added a new generator tooling suite for the VB.NET track that automates the creation of exercise scaffolding. The \generators\ directory now contains a CLI application (with \new\, \update\, and \sync\ commands) that parses canonical test data from the problem-specifications repository and generates both stub template files and full test suites using Scriban templates. This includes logic for handling test case filtering via \tests.toml\, formatting generated Visual Basic code via Roslyn, and managing naming conventions for test methods.

generators · high confidence

Added PowerShell scripts (test.ps1, update-tests.ps1, shared.ps1) and a Bash script (verify-exercises-in-docker) to the bin directory. The test script allows users to verify exercise solutions locally by copying exercises, enabling unit tests, and running dotnet test, with support for individual exercises. The update-tests script generates tests from canonical data using a .NET generator project. The Docker verification script pulls the VB.NET test runner image and validates exercises in an isolated container environment. The fetch-configlet script was also updated to support multiple operating systems and architectures.

bin · high confidence

The exercises solution file has been converted from the legacy .sln format to the new .slnx format. This change updates the underlying project metadata structure to use the newer XML-based solution definition, ensuring compatibility with updated tooling while maintaining the same set of practice exercises.

exercises · high confidence

The reverse-string exercise now provides a Visual Basic stub and test suite targeting .NET 10, utilizing the xUnit v3 testing framework (version 3.2.2) and the Exercism.Tests.xunit.v3 package. The included test cases cover standard string reversal, palindromes, and Unicode grapheme clusters, allowing users to implement the solution against a modernized test infrastructure.

exercises/practice/reverse-string · high confidence

The Binary exercise stubs and tests have been regenerated to use the xUnit v3 testing framework. This change updates the test structure to use the new \xunit.v3\ packages and \Exercism.Tests.xunit.v3\ library, replacing the previous xUnit version. Users will now see tests written with xUnit v3 syntax and conventions, ensuring compatibility with the latest testing infrastructure.

exercises/practice/binary · high confidence

All Visual Basic .NET practice exercise project files have been updated to target the .NET 10.0 framework and migrated to xUnit v3. This change updates the test dependencies to \xunit.v3\ (3.2.2), \Exercism.Tests.xunit.v3\ (0.1.0-beta1), and \Microsoft.NET.Test.Sdk\ (18.3.0), ensuring that the VB.NET track exercises are compatible with the latest .NET runtime and testing infrastructure.

(dependencies) · high confidence

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

• CAI 38 → 48 (+10.5)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 13 → 37 (+24.0)
• Architecture 69 (new)
• Maturity 49 → 48 (-1.2)
• Readiness 74 → 64 (-10.8)
• Security 83 → 87 (+3.7)

• Banned license: Exercism.Tests.xunit.v3
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Off-boarding risk: anonymized user #1
• Outdated: LibGit2Sharp
• Outdated: Microsoft.CodeAnalysis.VisualBasic.Workspaces
• Outdated: Microsoft.NET.Test.Sdk
• Outdated: Microsoft.Reactive.Testing
• Outdated: Scriban
• Outdated: Tomlyn
• Outdated: xunit.runner.visualstudio
• Outdated: xunit.v3
• Prerelease dependency: Exercism.Tests.xunit.v3

• 3 commits — 3 feature/other, 0 fixes

• exercises/practice — 2 commits
• .github/workflows — 1 commit

• change: Remove unhealthy hobby references (#587)
• change: Sync list-ops tests (#588)
• change: 🤖 Sync org-wide files to upstream repo (#586)

• Containers 1 added · 0 removed · contexts 0 added · 0 removed · edges 0 added · 0 removed

• cli:Generators

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

exercism/vbnet 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.