Selectivity.net

About

Sat, 24 Oct 2026 00:00:00 +0000

Selectivity is a command line reducer for failing inputs. It works on lines in a file or files in a directory, with an optional pass over the lines inside the files that remain. A command you supply decides whether the behavior of interest still occurs. Selectivity keeps a removal only when every configured observation confirms it.

The project exists because debugging a large input often starts with the same tedious exercise: remove something, rerun the program, check that the same problem survives, then repeat. Automating that exercise gives a developer a smaller input to inspect and a more useful attachment for a bug report. The developer still defines the failure. Selectivity does not diagnose the program or infer which crash matters.

Contact

Sat, 24 Oct 2026 00:00:00 +0000

Write to info@selectivity.net with questions about Selectivity, integration work or a reduction that behaves unexpectedly.

For a reproducible bug, the GitHub repository is also a useful starting point. Include the version, operating system and predicate contract, with a small input you can share. Avoid sending private production data. Reports can contain command arguments and captured program output, so check them before attaching anything.

Demo

Sat, 24 Oct 2026 00:00:00 +0000

Watch the candidate checks from a real run of the released Selectivity 0.1.1 binary. Choose the generated 20000-line input or the small directory bundle, then play the recording or advance one check at a time. The display distinguishes the candidate being tested from the latest input accepted by the predicate. A rejected candidate can be smaller than the saved input; it was rejected because its behavior did not qualify.

This is recorded evidence, rather than a command running in your browser. The line fixture needs alpha and omega. The directory fixture needs alpha in a.txt and omega in nested/b.txt. Both runs used a Linux amd64 container, one observation per candidate, and a five-second execution timeout. The command line default is three observations. The original input sizes were 408866 bytes and 39 bytes respectively.

Download

Sat, 24 Oct 2026 00:00:00 +0000

Selectivity is free software under Apache 2.0. Each archive includes the executable, manual and license notices. Choose the operating system and processor for the machine that will run your predicate.

Linux on Intel or AMD 64-bit

Linux on ARM64

macOS on Intel

macOS on Apple Silicon

Windows on Intel or AMD 64-bit

Use SHA256SUMS to check a downloaded archive. The permanent links above follow the latest full release. Versioned archives and release notes remain on the GitHub releases page.

Quick Start

Sat, 24 Oct 2026 00:00:00 +0000

Download the archive for your operating system from the download page and unpack it. Selectivity runs as one executable. On Linux or macOS, this small example starts with four lines and keeps the one recognized by grep:

printf 'first\nTRIGGER\nthird\nfourth\n' > failing.txt
./selectivity --input failing.txt --out reduction -- grep -q TRIGGER '{input}'

Open reduction/report.html when the run finishes. The original input is copied to reduction/original and the latest accepted input is saved as reduction/reduced. The output directory must be new, its parent must exist, and it must be outside the input. Command options go before the separator. The braces are part of the placeholder, so keep them.

Reference

Sat, 24 Oct 2026 00:00:00 +0000

Selectivity removes chunks from an ordered input and asks a predicate whether the behavior of interest survives. When a removal fails, it tries smaller chunks. Each accepted deletion restarts the search, ending with checks of single remaining units. Directory mode removes whole files, optionally reduces each remaining file by lines, and repeats until a full pass leaves the modeled input unchanged.

The predicate uses exit 0 for interesting input, 1 for uninteresting input and other exits for unresolved input. Every configured observation must return 0 before a candidate is accepted. Mixed observations are unstable, timeouts are unresolved, and neither justifies deletion. An original input that does not consistently satisfy the predicate is rejected before reduction. A final repeated check confirms the saved result at the end of a completed run.

Selectivity Finds the Two CSV Records Behind a Calculation Bug

Sat, 24 Oct 2026 00:00:00 +0000

A CSV importer can be wrong for a reason that disappears when a developer tests one record at a time. The example here needs a sequence: a discount for an order, followed later by a refund for that same order. A deliberately faulty importer deducts the refund twice when it has already seen a discount. A reference implementation deducts it once. The predicate compares the two results and asks Selectivity to preserve their disagreement.

Selectivity Isolates Numeric Precision Loss in JSON Lines

Sat, 24 Oct 2026 00:00:00 +0000

An input can be perfectly valid and still expose a disagreement between two consumers. In this example, one path keeps an integer identifier exactly as parsed. The other deliberately sends the identifier through a floating-point conversion before turning it back into an integer. Most of the generated JSON Lines records produce the same answer. One does not: 9007199254740993 becomes 9007199254740992 in the lossy path.

Selectivity starts with 150 independently valid records totaling 4144 bytes. The predicate parses every remaining line, checks its schema, then compares the exact identifier sequence with the lossy sequence. In one run of Selectivity 0.1.1 on Linux x86_64 with Python 3.12.14, the result is one 41-byte record. The reducer makes 36 predicate executions across 12 candidate checks, with three observations per candidate and a five-second timeout. There are no unresolved checks.

Selectivity Keeps a Useful Checkpoint When the Test Budget Runs Out

Sat, 24 Oct 2026 00:00:00 +0000

A reduction can be useful before it is finished. That matters when the predicate is expensive, a CI job has a fixed allowance, or a developer wants to make a first pass without committing to thousands of executions. Selectivity’s execution budget puts a bound on how many predicate processes can start. Reaching that limit leaves an incomplete run and the latest accepted checkpoint, rather than silently promoting unfinished work to a completed result.

Selectivity Makes Large Bug Reports Easier to Understand

Sat, 24 Oct 2026 00:00:00 +0000

A minimal reproducer is a small example that still demonstrates a problem. It gives the person investigating a bug less material to read and fewer irrelevant details to carry through each experiment. Getting there is often laborious. You remove a group of rows, rerun the program, discover that the failure has vanished, restore the rows and try a smaller group. It is useful work, just rather repetitive.

Selectivity turns that routine into a search driven by a predicate. The predicate is a command that answers whether the particular behavior survives in the candidate input. Selectivity begins with larger deletions and works toward smaller ones when necessary. Each successful deletion becomes the new starting point. Eventually the engine reaches individual units, such as one line or one file, and checks whether removing any of them still preserves the predicate.

Selectivity Reduces a Configuration Bundle by Files and Lines

Sat, 24 Oct 2026 00:00:00 +0000

The directory demonstration asks a slightly different question from the single-file example: can the reducer find both the relevant files and the relevant lines within them? The generated bundle starts with a.txt, nested/b.txt and junk.txt. The predicate needs alpha in the first file and omega in the nested file. Extra lines and the third file are unnecessary. It resembles a configuration bundle in shape, while remaining a generated text fixture with a known answer.

Selectivity Reduces a Generated File From 20000 Lines to Two

Sat, 24 Oct 2026 00:00:00 +0000

The line-reduction demonstration starts with a deliberately oversized text file whose answer is known in advance. It has 20000 lines: alpha appears on line 702, omega on line 17891, and every other line contains an irrelevant row label. The predicate succeeds only when both trigger lines are present. This makes a useful check of the reducer, because a result that loses either trigger is wrong and a result that keeps unnecessary lines is visibly unfinished.

Selectivity Reduces Failing Inputs and Records Every Candidate Check

Sat, 24 Oct 2026 00:00:00 +0000

A useful bug report often begins with an unhelpfully large attachment. The program fails on a particular export, configuration bundle or text file, but nobody knows which part matters. Selectivity automates the patient part of that investigation: remove some material, run a command that recognizes the target behavior, and keep the smaller input when the same behavior survives. The first release handles lines in a file and whole files in a directory, with an optional pass over the lines inside the remaining files.

Selectivity Takes Its Name From the Rule That Chooses What Survives

Sat, 24 Oct 2026 00:00:00 +0000

Selectivity is named for the decision at the center of every reduction. Some parts of an input are necessary to preserve the behavior under investigation. Other parts can disappear. The engine discovers useful deletions by applying a rule supplied by the developer, over and over, to progressively smaller candidates.

That rule is the predicate. It might recognize a specific crash, a disagreement between two parsers or a configuration combination that produces the wrong result. The same input can reduce differently under a different predicate, because a different question makes different material relevant. The name points to that dependence. Selectivity chooses what survives according to an explicit test.

Selectivity Tests Input Preservation and Uncertain Predicates

Sat, 24 Oct 2026 00:00:00 +0000

The central promise of a reducer is easy to state and surprisingly easy to weaken: the saved input should be smaller, while still satisfying the behavior being investigated. Testing only a successful reduction would miss several ways that promise can go wrong. Selectivity’s verification therefore checks the copies and the evidence around the search, alongside the search itself.

The automated tests cover line reduction, directory file removal and the optional line pass inside directory files. They also check empty input, raw line-ending preservation and files without a final newline. One predicate deliberately overwrites its disposable input. The saved result must still contain the accepted snapshot bytes, and the source must retain its original contents. A permissions test uses a restrictive creation mask to confirm that the copy restores the modeled file permissions explicitly.