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

{
  "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)

# 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)

// 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)

// 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

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

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

Citation

@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}
}