exercism/vbnet
44.2
Weak · 15 November 2026
653
lines of production code
VB.NET
primary language
5
measurements over time
What this system is
Features
Add 'Say' exercise for converting numbers to English words
Introduced the 'Say' exercise, which challenges users to convert integers from 0 to 999,999,999,999 into their English word representation. The addition includes the example solution (Example.vb), test generator template (Generator.tpl), configuration (config.json), and test metadata (tests.toml) for the Visual Basic track.
exercises/practice/say/.meta · high confidence
Add 'Say' exercise stub and tests for converting numbers to English words
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
Add Camicia card game exercise for Visual Basic
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
Add Diffie-Hellman exercise stub and tests for Visual Basic
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
Add Diffie-Hellman key exchange exercise for Visual Basic
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
Add ETL exercise stub and test suite for Visual Basic
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
Add Eliud's Eggs exercise for Visual Basic
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
Add EliudsEggs exercise stub and tests
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
Add Pascal's Triangle exercise for Visual Basic
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
Add Prism exercise stub and solution for Visual Basic
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
Add Saddle Points exercise stub and tests
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
Add Scale Generator exercise for Visual Basic
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
Add Secret Handshake exercise stub and tests for .NET 10
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
Add Sieve of Eratosthenes exercise for Visual Basic
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
Add Space Age exercise for Visual Basic
This change introduces the Space Age exercise for the Visual Basic track, providing the necessary metadata, test configuration, and a reference solution. Users can now complete the exercise, which requires calculating a person's age on different planets given their age in seconds. The entry includes the example implementation (Example.vb) that demonstrates the solution logic, the generator template (Generator.tpl) for creating test files, and the configuration files (config.json, tests.toml) that define the exercise structure and test cases for Earth, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, and Neptune.
exercises/practice/bank-account/.meta, exercises/practice/beer-song/.meta, exercises/practice/proverb/.meta · high confidence
Add Twelve Days of Christmas exercise for Visual Basic
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
Add VB.NET Hamming exercise metadata and example solution
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/crypto-square/.meta · high confidence
Add VB.NET Pythagorean Triplet exercise
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
Add VB.NET example implementation and metadata for RNA Transcription exercise
The RNA Transcription exercise now includes a Visual Basic .NET solution. This change adds the example implementation (Example.vb), which maps DNA nucleotides to their RNA complements and validates input, along with the corresponding generator template, configuration, and test metadata files required for the track.
exercises/practice/rna-transcription/.meta · high confidence
Add VB.NET example solution and test generator for the Clock exercise
This change introduces the reference implementation (Example.vb) and the test generator (Generator.tpl) for the Clock exercise in the VB.NET track. The example solution provides a class that handles time arithmetic, including rolling over hours and minutes, supporting addition and subtraction of minutes, and ensuring immutability by returning new instances rather than modifying state. The generator creates the corresponding test suite, covering scenarios such as creating clocks with initial times, adding/subtracting minutes across midnight, handling negative values, and comparing clocks for equality.
(repo-wide) · high confidence
Add VB.NET meetup exercise with example solution and test generator
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.
exercises/practice/resistor-color/.meta · high confidence
Add VB.NET phone-number exercise with validation logic
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
Add Variable Length Quantity exercise stub and tests for Visual Basic
This change introduces the Variable Length Quantity practice exercise for the Visual Basic track. It adds the initial solution stub (VariableLengthQuantity.vb) containing empty Encode and Decode methods, along with a comprehensive test suite (VariableLengthQuantityTests.vb) that covers encoding and decoding scenarios for single, double, triple, quadruple, and quintuple byte sequences, as well as edge cases like zero and maximum 32-bit integers. The entry also includes an .editorconfig file to enforce consistent coding styles and naming conventions for Visual Basic files, and a packages.lock.json file pinning the .NET 10.0 dependencies, specifically Exercism.Tests.xunit.v3, xunit.v3, and Microsoft.NET.Test.Sdk.
exercises/practice/resistor-color-trio · high confidence
Add Visual Basic Meetup exercise with xUnit v3 test scaffolding
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
Add Visual Basic example solution and metadata for the Affine Cipher exercise
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/bob/.meta · high confidence
Add Visual Basic example solution and test configuration for perfect-numbers
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
Add Visual Basic example solution and test generator for Collatz Conjecture
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).
exercises/practice/collatz-conjecture/.meta, exercises/practice/high-scores/.meta, exercises/practice/linked-list/.meta, exercises/practice/matching-brackets/.meta, exercises/practice/simple-linked-list/.meta · high confidence
Add Visual Basic grep exercise with xunit.v3 test suite
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/clock, exercises/practice/grep · high confidence
Add Visual Basic implementation for the Prime Factors exercise
A new Visual Basic track for the Prime Factors exercise has been added, providing the starter code (\PrimeFactors.vb\) and a corresponding test suite (\PrimeFactorsTests.vb\) that uses xUnit v3. The test file includes cases for prime numbers, composite numbers, and large inputs, with most tests initially skipped to guide learners. An \.editorconfig\ file is also included to enforce consistent coding styles and naming conventions for Visual Basic projects.
exercises/practice/prime-factors · high confidence
Add Visual Basic ledger exercise with locale-aware formatting
The Visual Basic track now includes the 'ledger' exercise, which challenges users to refactor a poorly written ledger printer. The provided solution demonstrates formatting currency and dates for American (en-US) and Dutch (nl-NL) locales, handling specific requirements like truncating long descriptions, sorting entries by date/description/change, and applying correct negative number patterns for USD and EUR.
exercises/practice/ledger · high confidence
Add Visual Basic linked-list exercise with xUnit v3 test framework
A new Visual Basic exercise for the linked-list (deque) problem has been added, providing a starter \Deque\ class with stub methods (\Push\, \Pop\, \Unshift\, \Shift\, \Delete\, \Count\) and a comprehensive test suite using the xUnit v3 framework. The project targets .NET 10.0 and includes an \.editorconfig\ file to enforce consistent coding styles, import organization, and naming conventions for Visual Basic developers.
exercises/practice/linked-list · high confidence
Add Visual Basic reference implementation and metadata for the Affine Cipher exercise
This change introduces the Visual Basic track support for the Affine Cipher exercise. It adds the canonical solution (Example.vb) which implements the encryption and decryption logic, including handling of coprime validation and character normalization. It also includes the test generator template (Generator.tpl) to create the corresponding test suite, along with the configuration (config.json) and test metadata (tests.toml) required for the exercise to be available to Visual Basic learners.
exercises/practice/affine-cipher/.meta · high confidence
Add Visual Basic solution and test generator for the Prime Factors exercise
This change introduces the Visual Basic track implementation for the Prime Factors exercise. It includes an example solution (Example.vb) that computes prime factors, a test generator template (Generator.tpl) to create test cases, and the necessary metadata files (config.json, tests.toml) to define the exercise structure and test cases for the track.
exercises/practice/prime-factors/.meta · high confidence
Add Visual Basic stubs and tests for the Allergies exercise
The Allergies exercise now includes a Visual Basic implementation stub (Allergies.vb) and a corresponding test suite (AllergiesTests.vb). The stub provides the class structure with methods for checking allergies and listing them, while the tests define the expected behavior for various allergy scenarios. This change also adds an .editorconfig file to enforce consistent coding styles and a packages.lock.json to pin the xunit.v3 testing framework dependencies for the exercise.
exercises/practice/allergies · high confidence
Add Visual Basic support for the Affine Cipher exercise
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
Add Zebra Puzzle exercise stub and test scaffolding
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
Added Crypto Square exercise stub and tests for Visual Basic
The Crypto Square exercise is now available for Visual Basic learners. This change introduces the initial stub file (\CryptoSquare.vb\) containing the \Ciphertext\ function signature, along with a corresponding test suite (\CryptoSquareTests.vb\) that validates the implementation against various scenarios such as normalization, character removal, and chunking. The project also includes an \.editorconfig\ to enforce consistent coding styles and a \packages.lock.json\ pinning the test dependencies to \xunit.v3\ (version 3.2.2) and \Exercism.Tests.xunit.v3\ (version 0.1.0-beta1) targeting .NET 10.0.
exercises/practice/crypto-square · high confidence
Added Two-Fer exercise stub and test suite for Visual Basic
The Two-Fer practice exercise is now available for Visual Basic, providing a starter project with an .editorconfig for consistent coding styles, a TwoFer.vb stub file containing the Speak method signature, and a TwoFerTests.vb test file. The test suite includes a passing test for the default case and skipped tests for cases where a name is provided, guiding users to implement the logic.
exercises/practice/two-fer · high confidence
Added VB.NET example solution and metadata for the reverse-string exercise
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
Added VB.NET example solution and test generator for the Accumulate exercise
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
Added Visual Basic generator for Resistor Color exercise
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
Added Visual Basic solution and test metadata for the Leap exercise
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
Bob exercise scaffolded with xUnit v3 tests and .editorconfig
The Bob exercise now includes a generated stub (Bob.vb) and a comprehensive test suite (BobTests.vb) using xUnit v3, along with an .editorconfig file to enforce consistent coding styles. The tests cover all standard Bob scenarios (questions, shouting, silence, etc.), with most cases initially skipped to guide learners through implementation.
exercises/practice/bob · high confidence
Hello World exercise metadata and example solution added
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
High Scores exercise scaffolded with .NET 10 and xUnit v3
The High Scores practice 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 adapter. The included test file defines the expected behavior for retrieving scores, the latest score, the personal best, and the top three scores, with most tests initially skipped to guide the learner. An .editorconfig file has also been added to enforce consistent coding styles, including specific Visual Basic modifier ordering and naming conventions.
exercises/practice/anagram, exercises/practice/high-scores · high confidence
Initial Hamming exercise stub and test suite for Visual Basic
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
Initial Visual Basic implementation for Matching Brackets exercise
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
Initial stub and test structure for the Accumulate exercise
This change introduces the initial file structure for the Visual Basic Accumulate exercise. It adds a stub implementation file (Accumulate.vb) containing an empty module for students to implement, a test file (AccumulateTests.vb) with pre-written test cases for various accumulation scenarios (such as squaring numbers, upcasing strings, and lazy evaluation), and an .editorconfig file to enforce consistent coding styles and naming conventions for Visual Basic projects. A packages.lock.json file is also included to pin the test dependencies, specifically targeting .NET 10.0 and using xunit.v3.
exercises/practice/accumulate · high confidence
Introduce VB.NET test and template generators
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
New VB.NET test and verification tooling in bin/
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
New parallel letter frequency exercise for Visual Basic
A new practice exercise has been added for the Visual Basic track, requiring users to count the frequency of letters in a list of texts using parallel computation. The entry includes the problem instructions, a stub implementation file (\ParallelLetterFrequency.vb\), a comprehensive test suite (\ParallelLetterFrequencyTests.vb\) covering scenarios such as case insensitivity, whitespace/punctuation/number ignoring, Unicode support, and large text inputs, along with an example solution, generator templates, and project configuration files.
exercises/practice/parallel-letter-frequency · high confidence
Behavioural changes
6 commits (0 fixes) modifying exercises/practice/leap
A change to existing behaviour in exercises/practice/leap — 6 commits, 4 files: “Add \Exercism.Tests.xunit.v3\ to .vbproj files (\#546)”; “Format files and other cleanup (\#412)”; “Upgrade to .NET 10 (\#407)”; and 3 more (refs \#546, \#412, \#407, \#563, \#100, …).
exercises/practice/leap · medium confidence · unverified
8 commits (1 fix) modifying exercises/practice/hello-world
A change to existing behaviour in exercises/practice/hello-world — 8 commits (1 fix), 4 files: “Add \Exercism.Tests.xunit.v3\ to .vbproj files (\#546)”; “Format files and other cleanup (\#412)”; “Upgrade to .NET 10 (\#407)”; and 5 more (refs \#546, \#412, \#407, \#112, \#98, …).
exercises/practice/hello-world · medium confidence · unverified
Migration to .slnx solution format
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
Reverse-string exercise scaffolded with .NET 10 and xUnit v3
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
Updated Binary exercise stubs and tests to use xUnit v3
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
Dependencies
VB.NET exercises upgraded to .NET 10 and xUnit v3
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 44 → 44 (+0.3)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 37 → 37 (+0.0)
- Architecture 69 → 69 (+0.0)
- Maturity 42 → 45 (+3.7)
- Readiness 44 → 44 (-0.5)
- Security 87 → 78 (-8.6)
Resolved (3)
- Coverage not measured — no coverage collector is wired up
- No ADRs found
- Off-boarding risk: anonymized user #1
New (7)
- Low coverage: generators/Exercises.vb (generators/Exercises.vb)
- Low coverage: generators/Paths.vb (generators/Paths.vb)
- Low coverage: generators/Program.vb (generators/Program.vb)
- Low coverage: generators/TemplateGenerator.vb (generators/TemplateGenerator.vb)
- Low coverage: generators/TestsGenerator.vb (generators/TestsGenerator.vb)
- No ADRs found (generators/Generators.vbproj)
- Off-boarding risk: anonymized user #1
Changes since last survey
- 3 commits — 3 feature/other, 0 fixes
By area
- .github/CODEOWNERS — 2 commits
- exercises/practice — 1 commit
Notable commits
- change: Add a sign-up snippet (#590)
- change: List the checks that must pass before a PR can merge (#591)
- change: 🤖 Auto-sync docs, metadata, and filepaths (#593)
Architecture
- Unchanged — 1 containers · 0 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 8f2d425002a1d13130f32ec1b32d9e3a64258628 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.