Datasets:

SalutefaceAAC
/

code-smell-detection

---
license: apache-2.0
language:
- en
tags:
- code
- software-engineering
- synthetic
- code-quality
- refactoring
- static-analysis
task_categories:
- text-classification
- text-generation
pretty_name: Code Smell Detection
size_categories:
- n<1K
---
# Code Smell Detection

A curated synthetic dataset of **103 hand-authored code snippets** labelled with software engineering code smells across **6 languages** and **20 smell types**, including a clean negative class (~6%). Designed for training classifiers, evaluating LLM code-review capability, and teaching refactoring principles.

## Dataset Summary

| Attribute | Value |
|---|---|
| Total examples | 103 |
| Languages | Python, JavaScript, TypeScript, Go, Java, Rust |
| Smell types | 20 (+ clean negative class) |
| Splits | train (72) / val (15) / test (16) |
| License | Apache 2.0 |

## Smell Types

| Smell Type | Count | Description |
|---|---|---|
| `long_method` | 5 | Methods too long to understand at a glance |
| `large_class` | 5 | Classes with too many responsibilities |
| `god_object` | 5 | Objects that know/do too much |
| `feature_envy` | 7 | Methods more interested in another class's data |
| `data_clumps` | 6 | Groups of primitives that belong in an object |
| `primitive_obsession` | 5 | Using primitives instead of value objects |
| `switch_statements` | 5 | Repeated switch/if-else on a type discriminator |
| `speculative_generality` | 6 | Unused abstraction added for hypothetical futures |
| `comments_as_smell` | 6 | Comments that compensate for poor naming |
| `temporary_field` | 4 | Fields only set during one method call |
| `message_chains` | 6 | Long chains of getters/method calls |
| `middle_man` | 5 | Classes that only delegate to another class |
| `inappropriate_intimacy` | 4 | Classes accessing each other's private internals |
| `refused_bequest` | 4 | Subclasses that reject inherited interface |
| `lazy_class` | 5 | Classes that do too little to justify existence |
| `alternative_classes` | 5 | Two classes doing the same thing with different names |
| `dead_code` | 5 | Unreachable, deprecated, or commented-out code |
| `parallel_inheritance` | 4 | Two class hierarchies that must change in lockstep |
| `incomplete_library` | 5 | Re-implementing what a standard library already provides |
| `none` | 6 | **Clean negative class** — well-written code with no smell |

## Schema

```python
{
  "id": str,                    # 16-char MD5 hex
  "language": str,              # python | javascript | typescript | go | java | rust
  "smell_type": str,            # see table above; "none" for clean examples
  "severity": str,              # low | medium | high | none (none for clean examples)
  "code_snippet": str,          # the code to evaluate
  "smell_explanation": str,     # why this is a smell (or why it's clean)
  "refactoring_suggestion": str,# how to fix it (or "No refactoring needed." for clean)
  "difficulty": str             # beginner | intermediate | advanced
}
```

## Sample Records

### Example 1 — `feature_envy` (Python, beginner)
```python
# code_snippet:
class Report:
    def __init__(self, data_source):
        self.data_source = data_source
    def generate(self):
        records = self.data_source.records
        total = sum(r.amount for r in self.data_source.records if r.status == 'paid')
        overdue = [r for r in self.data_source.records if r.due_date < datetime.today() and r.status != 'paid']
        avg = total / len(self.data_source.records) if self.data_source.records else 0
        return {'total_paid': total, 'overdue_count': len(overdue), 'average': avg}
# smell_explanation:
# Report.generate() repeatedly reaches into data_source internals (records, amounts, statuses,
# due_dates). The method is more interested in DataSource's data than in Report's own
# responsibilities — a classic Feature Envy.
# refactoring_suggestion:
# Move the aggregation logic to DataSource as paid_total(), overdue_records(), and
# average_amount() methods. Report.generate() then just calls data_source.summary().
```
### Example 2 — `message_chains` (TypeScript, advanced)
```typescript
// code_snippet:
function applyDiscount(context: RequestContext): number {
  return context
    .getSession()
    .getCurrentUser()
    .getSubscription()
    .getPlan()
    .getDiscountPolicy()
    .calculateDiscount(context.getCart().getTotalAmount());
}
// smell_explanation:
// A 7-deep chain crosses five domain objects to reach a discount calculation.
// Depends on the shape of five intermediate types, impossible to unit-test without a
// full context graph, and violates the Law of Demeter severely.

// refactoring_suggestion:
// Move calculateDiscount to a DiscountService that accepts (userId, planId, cartTotal),
// or to User.calculateDiscount(cartTotal) if discount is user-scoped.
```
### Example 3 — `none` (Go, intermediate, clean)
```go
// code_snippet:
type Money struct {
    amount   int64  // stored in cents
    currency string // ISO 4217
}
func NewMoney(amount int64, currency string) (Money, error) {
    if amount < 0 { return Money{}, fmt.Errorf("amount must be non-negative") }
    if len(currency) != 3 { return Money{}, fmt.Errorf("invalid currency code") }
    return Money{amount: amount, currency: currency}, nil
}
func (m Money) Add(other Money) (Money, error) {
    if m.currency != other.currency {
        return Money{}, fmt.Errorf("currency mismatch: %s vs %s", m.currency, other.currency)
    }
    return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}
// smell_explanation:
// Clean value object pattern: Money is immutable, validated at construction,
// stores currency-safe integer amounts, and arithmetic is type-safe. No smell.
```
## Usage
```python
from datasets import load_dataset

ds = load_dataset("SalutefaceAAC/code-smell-detection")
print(ds["train"][0])
# Filter by language and severity
train_df = ds["train"].to_pandas()
high_severity = train_df[(train_df.language == "python") & (train_df.severity == "high")]
# Classify: positive examples only
positive = train_df[train_df.smell_type != "none"]
```
### LLM Evaluation Prompt
```python
def make_eval_prompt(snippet: str) -> str:
    return f"""Analyze the following code snippet for software engineering code smells.
Identify the primary smell type (or "none" if the code is clean), its severity (low/medium/high/none),
explain why it is or isn't a smell, and suggest a refactoring if applicable.
Code:
{snippet}

Respond in JSON: {{"smell_type": "...", "severity": "...", "explanation": "...", "refactoring": "..."}}"""
```
## Methodology
Examples were hand-authored following these principles:
- **Authenticity**: Each snippet resembles real-world code that would appear in a production codebase, not toy examples.
- **Language idiomatic**: Each language's conventions (Go interfaces, Rust newtype, Java Spring, TypeScript generics) are respected.
- **Negative class**: 6 clean examples (~6%) prevent classifiers from learning a trivial "always smelly" bias.
- **Severity calibration**: `high` = structural problem affecting testability/extensibility; `medium` = noticeable but contained; `low` = minor style or maintenance debt.
- **Difficulty calibration**: `beginner` = recognisable pattern, one-line fix; `intermediate` = requires understanding domain/architecture; `advanced` = multi-class refactoring or architectural pattern.
## Limitations
- 103 examples — suitable for evaluation, fine-tuning small classifiers, or few-shot prompting; not sufficient for training large models from scratch.
- Python is over-represented (29/103) relative to Rust (9/103); balance will improve in v1.5.
- Snippets are self-contained stubs; real code smells often span multiple files.
- The taxonomy follows Fowler's *Refactoring* (2nd ed.) and Kerievsky's *Refactoring to Patterns*; some newer smells (e.g., async anti-patterns, microservice coupling) are not yet covered.
- LLM-generated explanations: while hand-authored, these reflect the author's (agent's) interpretation of each smell, not a community consensus annotation.
## Related Datasets
- [SalutefaceAAC/synthetic-code-review-comments](https://huggingface.co/datasets/SalutefaceAAC/synthetic-code-review-comments)
- [SalutefaceAAC/unit-test-edge-cases](https://huggingface.co/datasets/SalutefaceAAC/unit-test-edge-cases)
- [SalutefaceAAC/api-error-resolution-pairs](https://huggingface.co/datasets/SalutefaceAAC/api-error-resolution-pairs)
- [SalutefaceAAC/structured-output-generation](https://huggingface.co/datasets/SalutefaceAAC/structured-output-generation)
## Citation
```bibtex
@dataset{saluteface_code_smell_2026,
  author    = {SalutefaceAAC},
  title     = {Code Smell Detection},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/SalutefaceAAC/code-smell-detection},
  license   = {Apache-2.0}
}
```

	---
	license: apache-2.0
	language:
	- en
	tags:
	- code
	- software-engineering
	- synthetic
	- code-quality
	- refactoring
	- static-analysis
	task_categories:
	- text-classification
	- text-generation
	pretty_name: Code Smell Detection
	size_categories:
	- n<1K
	---

	# Code Smell Detection

	A curated synthetic dataset of 103 hand-authored code snippets labelled with software engineering code smells across 6 languages and 20 smell types, including a clean negative class (~6%). Designed for training classifiers, evaluating LLM code-review capability, and teaching refactoring principles.

	## Dataset Summary

	\| Attribute \| Value \|
	\|---\|---\|
	\| Total examples \| 103 \|
	\| Languages \| Python, JavaScript, TypeScript, Go, Java, Rust \|
	\| Smell types \| 20 (+ clean negative class) \|
	\| Splits \| train (72) / val (15) / test (16) \|
	\| License \| Apache 2.0 \|

	## Smell Types

	\| Smell Type \| Count \| Description \|
	\|---\|---\|---\|
	\| `long_method` \| 5 \| Methods too long to understand at a glance \|
	\| `large_class` \| 5 \| Classes with too many responsibilities \|
	\| `god_object` \| 5 \| Objects that know/do too much \|
	\| `feature_envy` \| 7 \| Methods more interested in another class's data \|
	\| `data_clumps` \| 6 \| Groups of primitives that belong in an object \|
	\| `primitive_obsession` \| 5 \| Using primitives instead of value objects \|
	\| `switch_statements` \| 5 \| Repeated switch/if-else on a type discriminator \|
	\| `speculative_generality` \| 6 \| Unused abstraction added for hypothetical futures \|
	\| `comments_as_smell` \| 6 \| Comments that compensate for poor naming \|
	\| `temporary_field` \| 4 \| Fields only set during one method call \|
	\| `message_chains` \| 6 \| Long chains of getters/method calls \|
	\| `middle_man` \| 5 \| Classes that only delegate to another class \|
	\| `inappropriate_intimacy` \| 4 \| Classes accessing each other's private internals \|
	\| `refused_bequest` \| 4 \| Subclasses that reject inherited interface \|
	\| `lazy_class` \| 5 \| Classes that do too little to justify existence \|
	\| `alternative_classes` \| 5 \| Two classes doing the same thing with different names \|
	\| `dead_code` \| 5 \| Unreachable, deprecated, or commented-out code \|
	\| `parallel_inheritance` \| 4 \| Two class hierarchies that must change in lockstep \|
	\| `incomplete_library` \| 5 \| Re-implementing what a standard library already provides \|
	\| `none` \| 6 \| Clean negative class — well-written code with no smell \|

	## Schema

	```python
	{
	"id": str, # 16-char MD5 hex
	"language": str, # python \| javascript \| typescript \| go \| java \| rust
	"smell_type": str, # see table above; "none" for clean examples
	"severity": str, # low \| medium \| high \| none (none for clean examples)
	"code_snippet": str, # the code to evaluate
	"smell_explanation": str, # why this is a smell (or why it's clean)
	"refactoring_suggestion": str,# how to fix it (or "No refactoring needed." for clean)
	"difficulty": str # beginner \| intermediate \| advanced
	}
	```

	## Sample Records

	### Example 1 — `feature_envy` (Python, beginner)
	```python
	# code_snippet:
	class Report:
	def __init__(self, data_source):
	self.data_source = data_source

	def generate(self):
	records = self.data_source.records
	total = sum(r.amount for r in self.data_source.records if r.status == 'paid')
	overdue = [r for r in self.data_source.records if r.due_date < datetime.today() and r.status != 'paid']
	avg = total / len(self.data_source.records) if self.data_source.records else 0
	return {'total_paid': total, 'overdue_count': len(overdue), 'average': avg}

	# smell_explanation:
	# Report.generate() repeatedly reaches into data_source internals (records, amounts, statuses,
	# due_dates). The method is more interested in DataSource's data than in Report's own
	# responsibilities — a classic Feature Envy.

	# refactoring_suggestion:
	# Move the aggregation logic to DataSource as paid_total(), overdue_records(), and
	# average_amount() methods. Report.generate() then just calls data_source.summary().
	```

	### Example 2 — `message_chains` (TypeScript, advanced)
	```typescript
	// code_snippet:
	function applyDiscount(context: RequestContext): number {
	return context
	.getSession()
	.getCurrentUser()
	.getSubscription()
	.getPlan()
	.getDiscountPolicy()
	.calculateDiscount(context.getCart().getTotalAmount());
	}

	// smell_explanation:
	// A 7-deep chain crosses five domain objects to reach a discount calculation.
	// Depends on the shape of five intermediate types, impossible to unit-test without a
	// full context graph, and violates the Law of Demeter severely.

	// refactoring_suggestion:
	// Move calculateDiscount to a DiscountService that accepts (userId, planId, cartTotal),
	// or to User.calculateDiscount(cartTotal) if discount is user-scoped.
	```

	### Example 3 — `none` (Go, intermediate, clean)
	```go
	// code_snippet:
	type Money struct {
	amount int64 // stored in cents
	currency string // ISO 4217
	}

	func NewMoney(amount int64, currency string) (Money, error) {
	if amount < 0 { return Money{}, fmt.Errorf("amount must be non-negative") }
	if len(currency) != 3 { return Money{}, fmt.Errorf("invalid currency code") }
	return Money{amount: amount, currency: currency}, nil
	}

	func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
	return Money{}, fmt.Errorf("currency mismatch: %s vs %s", m.currency, other.currency)
	}
	return Money{amount: m.amount + other.amount, currency: m.currency}, nil
	}

	// smell_explanation:
	// Clean value object pattern: Money is immutable, validated at construction,
	// stores currency-safe integer amounts, and arithmetic is type-safe. No smell.
	```

	## Usage

	```python
	from datasets import load_dataset

	ds = load_dataset("SalutefaceAAC/code-smell-detection")
	print(ds["train"][0])

	# Filter by language and severity
	train_df = ds["train"].to_pandas()
	high_severity = train_df[(train_df.language == "python") & (train_df.severity == "high")]

	# Classify: positive examples only
	positive = train_df[train_df.smell_type != "none"]
	```

	### LLM Evaluation Prompt
	```python
	def make_eval_prompt(snippet: str) -> str:
	return f"""Analyze the following code snippet for software engineering code smells.
	Identify the primary smell type (or "none" if the code is clean), its severity (low/medium/high/none),
	explain why it is or isn't a smell, and suggest a refactoring if applicable.

	Code:
	{snippet}

	Respond in JSON: {{"smell_type": "...", "severity": "...", "explanation": "...", "refactoring": "..."}}"""
	```

	## Methodology

	Examples were hand-authored following these principles:
	- Authenticity: Each snippet resembles real-world code that would appear in a production codebase, not toy examples.
	- Language idiomatic: Each language's conventions (Go interfaces, Rust newtype, Java Spring, TypeScript generics) are respected.
	- Negative class: 6 clean examples (~6%) prevent classifiers from learning a trivial "always smelly" bias.
	- Severity calibration: `high` = structural problem affecting testability/extensibility; `medium` = noticeable but contained; `low` = minor style or maintenance debt.
	- Difficulty calibration: `beginner` = recognisable pattern, one-line fix; `intermediate` = requires understanding domain/architecture; `advanced` = multi-class refactoring or architectural pattern.

	## Limitations

	- 103 examples — suitable for evaluation, fine-tuning small classifiers, or few-shot prompting; not sufficient for training large models from scratch.
	- Python is over-represented (29/103) relative to Rust (9/103); balance will improve in v1.5.
	- Snippets are self-contained stubs; real code smells often span multiple files.
	- The taxonomy follows Fowler's Refactoring (2nd ed.) and Kerievsky's Refactoring to Patterns; some newer smells (e.g., async anti-patterns, microservice coupling) are not yet covered.
	- LLM-generated explanations: while hand-authored, these reflect the author's (agent's) interpretation of each smell, not a community consensus annotation.

	## Related Datasets

	- [SalutefaceAAC/synthetic-code-review-comments](https://huggingface.co/datasets/SalutefaceAAC/synthetic-code-review-comments)
	- [SalutefaceAAC/unit-test-edge-cases](https://huggingface.co/datasets/SalutefaceAAC/unit-test-edge-cases)
	- [SalutefaceAAC/api-error-resolution-pairs](https://huggingface.co/datasets/SalutefaceAAC/api-error-resolution-pairs)
	- [SalutefaceAAC/structured-output-generation](https://huggingface.co/datasets/SalutefaceAAC/structured-output-generation)

	## Citation

	```bibtex
	@dataset{saluteface_code_smell_2026,
	author = {SalutefaceAAC},
	title = {Code Smell Detection},
	year = {2026},
	publisher = {Hugging Face},
	url = {https://huggingface.co/datasets/SalutefaceAAC/code-smell-detection},
	license = {Apache-2.0}
	}
	```