Update README.md

README.md

@@ -15,73 +15,100 @@ tags:
   - c
   - cpp
   - rust
+  - sorting-algorithms
+  - data-structures
+  - synthetic
 pretty_name: Multi-Language Programming Code Dataset
 size_categories:
-  - n<1K
+  - 1K<n<10K
 ---
 
 # Multi-Language Programming Code Dataset
 
-A small, hand-curated dataset of **original, non-scraped** code examples across 7
-programming environments: **Python, JavaScript, Node.js, Java, C, C++, and Rust**.
+A curated dataset of **original, non-scraped** code examples across 7 programming
+environments: **Python, JavaScript, Node.js, Java, C, C++, and Rust**.
 
-Every task/code pair covers the same 15 core programming concepts in each language,
-making the dataset useful for cross-language comparison, few-shot prompting,
-code-explanation fine-tuning, or as a seed set to expand with your own generation
-pipeline.
+The dataset ships in two parts that can be used separately or combined:
 
-> **Note:** Node.js is a JavaScript *runtime*, not a separate language. It's included
-> as its own split here because it exposes different APIs (filesystem, `Buffer`,
-> `process`, `http`, CommonJS modules) than browser-context JavaScript, which is
-> often exactly what people mean when they say "Node.js code."
+| File | Rows | Description |
+|---|---|---|
+| `code_dataset.jsonl` / `.csv` | 105 | Hand-written "core concepts" set — one clean example per language per concept (Hello World, OOP, error handling, recursion, async, etc.) |
+| `code_dataset_large.jsonl` / `.csv` | 2,255 | Template-generated, parameter-varied set covering **sorting algorithms, data structures, and string manipulation** in depth |
+
+> **Note on Node.js:** Node.js is a JavaScript *runtime*, not a separate language.
+> It's included as its own split because it exposes different APIs (filesystem,
+> `Buffer`, `process`, `http`, CommonJS modules) than browser-context JavaScript —
+> which is usually what people actually mean by "Node.js code."
 
 ## Dataset Structure
 
+Both files share the same schema:
+
 | Column | Description |
 |---|---|
-| `id` | Unique row identifier |
+| `id` | Unique row identifier (per file) |
 | `language` | One of: Python, JavaScript, Node.js, Java, C, C++, Rust |
-| `category` | Concept covered (see list below) |
+| `category` | Concept/topic covered |
 | `difficulty` | `beginner`, `intermediate`, or `advanced` |
 | `task_description` | Natural-language description of the coding task |
-| `code` | The original code snippet solving the task |
+| `code` | The code snippet solving the task |
 | `explanation` | A short note on the key language feature/idiom used |
 
-**105 rows** = 7 languages × 15 categories.
-
-## Categories (15 per language)
+## `code_dataset` (105 rows) — Core Concepts
 
+15 categories × 7 languages, one example each:
 Hello World · Variables and Data Types · Control Flow · Loops · Functions ·
 Arrays and Lists · Dictionaries and Maps · Classes and OOP · Error Handling ·
 File I/O · String Manipulation · Recursion · Sorting Algorithm ·
 Async and Concurrency · Data Structures
 
+## `code_dataset_large` (2,255 rows) — Deep Coverage on 3 Categories
+
+Generated by varying real parameters — algorithm choice, data type, sample
+values, operation sequences, and identifier names — **not** by duplicating
+templates with find-and-replace. Breakdown:
+
+| Category | Rows | What varies |
+|---|---|---|
+| Sorting Algorithm | 756 | Algorithm (bubble/selection/insertion), data type (int/float), array size (5–20 elements), 3 random samples per config |
+| Data Structures | 448 | Stack vs. Queue, data type (int/float), 4 distinct push/pop operation sequences, random values |
+| String Manipulation | 1,051 | Operation (palindrome check, reverse, word count, vowel count), 20 distinct test strings, varied function names |
+
+Distribution is balanced across languages (~320–326 rows each) and skews
+`intermediate` (1,727) over `beginner` (528), reflecting the algorithmic focus
+of this batch. Exact-duplicate rows were checked and removed (~3% collision
+rate from small-integer arrays landing on the same random sample).
+
 ## Files
 
-- `code_dataset.jsonl` — one JSON object per line (recommended for HF `datasets.load_dataset("json", ...)`)
-- `code_dataset.csv` — same data, spreadsheet-friendly
+- `code_dataset.jsonl` / `code_dataset_large.jsonl` — one JSON object per line (recommended for `datasets.load_dataset("json", ...)`)
+- `code_dataset.csv` / `code_dataset_large.csv` — same data, spreadsheet-friendly
+- `generate_dataset.py` — generator for the 105-row core set (add more languages/categories by adding `add(...)` calls)
+- `generate_batch.py` — generator for the 2,255-row deep-coverage set (add more categories/algorithms by extending the template dicts)
 
 ## Provenance & License
 
-All code snippets were **written from scratch** for this dataset (not scraped from
-GitHub or any other source), so there are no third-party license conflicts.
-Released under **MIT** — free to use, modify, and redistribute, including for
-model training.
+All code was **written from scratch** (hand-authored for the core set;
+programmatically templated with varied real parameters for the large set) —
+nothing was scraped from GitHub or any other source, so there are no
+third-party license conflicts. Released under **MIT** — free to use, modify,
+and redistribute, including for model training.
 
 ## Known Limitations
 
-- Small (105 rows) — meant as a clean seed set / benchmark slice, not a
-  large-scale pretraining corpus. For that, pair it with something like
+- The 2,255-row set currently covers only 3 categories in depth (sorting,
+  data structures, strings). Categories like "Hello World" or "Variables"
+  don't have enough genuine variation to scale the same way — padding them
+  would mean shallow repetition rather than useful diversity.
+- For large-scale pretraining, pair this with an established corpus like
   [The Stack](https://huggingface.co/datasets/bigcode/the-stack) or
   [CodeSearchNet](https://huggingface.co/datasets/code_search_net).
-- Only 7 languages/environments — easy to extend by adding more `add(...)` calls
-  to the included generator script (`generate_dataset.py`) if you want to grow
-  coverage yourself.
-- Snippets favor clarity/idiom over production hardening (e.g., minimal input
-  validation) — they're meant to teach the *pattern*, not be copy-paste production code.
+- Snippets favor clarity/idiom over production hardening (minimal input
+  validation) — they teach the *pattern*, not production-ready code.
 
-## Example Row
+## Example Rows
 
+**Core set:**
 ```json
 {
   "id": 1,
@@ -94,18 +121,34 @@ model training.
 }
 ```
 
+**Large set:**
+```json
+{
+  "id": 11,
+  "language": "Python",
+  "category": "Sorting Algorithm",
+  "difficulty": "intermediate",
+  "task_description": "Sort a 12-element array of ints in ascending order using bubble sort.",
+  "code": "def bubble_sort(entries):\n    n = len(entries)\n    ...",
+  "explanation": "Bubble sort on int data, variable named 'entries', 12 elements."
+}
+```
+
 ## Loading
 
 **Hugging Face `datasets`:**
 ```python
 from datasets import load_dataset
-ds = load_dataset("json", data_files="code_dataset.jsonl")
+core = load_dataset("json", data_files="code_dataset.jsonl")
+large = load_dataset("json", data_files="code_dataset_large.jsonl")
 ```
 
 **Pandas / Kaggle:**
 ```python
 import pandas as pd
-df = pd.read_csv("code_dataset.csv")
+core = pd.read_csv("code_dataset.csv")
+large = pd.read_csv("code_dataset_large.csv")
+combined = pd.concat([core, large], ignore_index=True)
 ```
 
 ## Suggested Uses
@@ -114,4 +157,12 @@ df = pd.read_csv("code_dataset.csv")
 - Few-shot prompting examples for a coding assistant
 - Cross-language idiom comparison (e.g., "how does error handling differ
   between Python and Rust?")
+- Algorithm-variant training data (many sorting/data-structure/string
+  examples with controlled, labeled variation)
 - A regression-test seed set for code-generation model evals
+
+## Roadmap
+
+The large set can be extended the same way to more categories (recursion,
+OOP, error handling, file I/O, async) by adding template functions to
+`generate_batch.py` — happy to keep scaling this up on request.