MaramAllah/td-forecasting-mart

Weekly snapshots of open-source Java projects measured with SonarQube, CKJM Extended, Halstead, Java Driller and git, at project, module and file level, for technical-debt forecasting. Method follows Tsoukalas et al. (2020), Technical debt forecasting: An empirical study on open-source repositories, Journal of Systems and Software 170:110777, https://doi.org/10.1016/j.jss.2020.110777. Values are measured from each project's own git history; the paper's published data is used only as a benchmark.

Load one level: datasets.load_dataset("MaramAllah/td-forecasting-mart", "file"), or pandas.read_parquet("hf://datasets/MaramAllah/td-forecasting-mart/mart_file.parquet").

Technical-debt data mart

Made 2026-10-20 with td_pipeline (SonarQube + CKJM Extended + Halstead + git), following Tsoukalas et al. (2020) "Technical debt forecasting: An empirical study on open-source repositories".

Projects

project_id	snapshot_method	weeks_ok	weeks_planned	weeks_failed	first_week	last_week	modules	file_rows
retrofit	paper_aligned	99	100	1	2017-01-27	2018-12-21	19	10515
commonsio	paper_aligned	330	332	2	2006-12-04	2018-07-28	1	32243
java_websocket	paper_aligned	94	98	4	2017-03-17	2019-01-25	1	5576
zxing	weekly_on_paper_dates	100	100	0	2017-03-10	2019-02-01	7	27540
okhttp	paper_aligned	150	150	0	2015-12-18	2018-10-26	22	26879
dubbo	weekly_on_paper_dates	78	80	2	2017-07-28	2019-02-01	74	63534

snapshot_method: paper_aligned = every row is the commit behind a paper row (matched by content: Java lines + file count), so it can be compared with the paper week by week · weekly_on_paper_dates = the paper's rows match no commit (it scanned a different scope), so one real commit per week on the paper's dates; compare with the paper by trend only · weekly = not a paper repo, one real commit per week.

Files

File	Rows	Columns
mart_project.csv	851	172
mart_module.csv	8,993	172
mart_file.csv	166,287	183
mart_all_levels.csv	176,131	206
*.parquet	same as the CSVs	same; typed and compressed (pandas read_parquet, Hugging Face)
diagnostics/<project>/	-	per-week status, build errors, preflight, build settings, analyzer, validation
data_dictionary.csv	one row per column	meaning, unit, valid range, levels
validation_report.txt	-	automatic checks per project (+ comparison with the paper)

• One row = one week (snapshot) of one project, module or Java file.
• mart_all_levels.csv = the three stacked; filter with the level column.
• Keys: project_id, level, week, module, file. sha = commit analysed.
• Target: total_principal (minutes) = sonar_sqale_index + sonar_reliability_remediation_effort + sonar_security_remediation_effort. td_density = total_principal / sonar_ncloc.
• Column groups (prefix): sonar_ SonarQube, ck_ CKJM Extended (LOC-weighted average per class), halstead_ Halstead, git_ git activity (since the previous snapshot, or over _Nd day windows).

How it was made

1. Weekly snapshots: for paper projects, every paper row was matched to its real commit by content (Java lines, pom.xml lines, file count) - the paper's date labels do not follow the real commit dates. week = paper label, commit_date = real commit date.
2. Each snapshot: built with JDK 8 / Maven 3.6.3 (tests skipped), analysed with SonarQube Community (current version, Standard Experience mode, Java profile Sonar way comprehensive), main Java code only.
3. CK metrics: CKJM Extended on the compiled classes, class values averaged with class LOC as the weight (paper sec. 4.2), at file/module/project level.
4. Halstead: javalang tokens; operators = operators + all keywords, operands = identifiers + literals; module/project use the union of distinct tokens.
5. Git: commits between the previous snapshot and this one, merges excluded, authors by e-mail.

Things to know before modelling

• Uneven real time: paper weeks are not 7 real days apart. git_window_days gives the real length of each window; same_commit_as_prev_week = 1 means the values just repeat.
• Missing weeks: a commit that could not be built is missing (days_since_prev_week = 14).
• Module (project) (module level): issues SonarQube raises on the whole project, not on any module. Keep it if module totals must equal the project; drop it for per-module models.
• TD level vs paper: the newer SonarQube rule set gives a lower TD level than the paper (retrofit: ~60%), but the trend agrees (Spearman rho 0.95-0.99). Size/complexity/duplication match exactly. Per-project numbers are in validation_report.txt.
• sonar_coverage is empty (not measured: tests were not run, as in the paper) and sonar_uncovered_lines = sonar_lines_to_cover.
• File level: package-info.java and Kotlin files have no CK / Halstead values (no Java class).
• Empty values at file level - three kinds, handled differently:
  1. Real zeros (sonar_ counts/efforts, total_principal): SonarQube omits a measure when it is 0 for a file. Filled with 0 - this is the true value, not an imputation (checked: files then add up exactly to the project totals). Do NOT impute these with mean/median.
  2. Does not apply (ck_, halstead_ for package-info.java / Kotlin files): left empty, flagged by has_ck, has_halstead, is_package_info. Tree models (XGBoost/LightGBM) handle empty natively; otherwise drop rows with is_package_info = 1 (they have no TD).
  3. Not measured (sonar_coverage): tests were not run, so it is empty everywhere - drop it.
• Java Driller cohesion (jd_cohesion) is often empty, on purpose. It is 1 / LCOM4 and is empty when no class in the file has a method with code: interfaces, annotation types (@GET), enums, exception classes with only constructors. The empty share shows the repo's design style, not a data problem (share of file rows: commons-io 6.0%, zxing 8.4%, okhttp 15.4%, dubbo 22.0%, retrofit 35.2%, java-websocket 47.0%). Keep it empty ("does not apply"); do not fill with 0.
• Zero-inflated target at file level: most files have total_principal = 0. Consider log1p(total_principal), a Tweedie/Poisson loss, or a two-step model (any TD? -> how much?).
• Modules come and go: modules are added, moved or removed over time (e.g. converters/adapters), so the module panel is unbalanced - a module has rows only for weeks where it existed. The same holds for files.
• Same commit, tiny differences: in 2 of the repeated-commit weeks, SonarQube reported 1 extra code smell (+10 min) on the identical code - SonarQube itself is not 100% deterministic. Effect < 0.5%.
• Constant / empty columns (no information): sonar_coverage (empty), sonar_*_rating, ck_n_dropped.
• Target leakage - do NOT use as features when predicting total_principal of the same week: td_density, sonar_sqale_index, sonar_reliability_remediation_effort, sonar_security_remediation_effort (they ARE the target's parts), sonar_sqale_debt_ratio (= sqale_index / ncloc). For forecasting (predict week t+h from weeks <= t), past values of these are fine and useful.
• Strongly related features: sonar_ncloc, sonar_lines, sonar_statements, halstead_length and ck_LOC all measure size (correlation ~1). Pick one or reduce them.
• Git at module level: git_commit_count / git_contributors_count count commits/authors that touched the module, so a commit touching 2 modules counts in both - module values add up to MORE than the project. Lines added/deleted/churn add up exactly. Changes to files outside every Java module (root pom.xml, README, ...) are in the (project) row.
• Files with holes: a few files disappear and come back later (deleted and re-created, e.g. RequestFactory.java). That is real history, not missing data.
• git_window_days is 0 for weeks that repeat the previous commit and up to ~68 days elsewhere.
• The paper normalised bugs, code_smells, duplicated_blocks, Ca (its selected features) and the target by ncloc before regression - do the same if you reproduce it.

Java Driller columns (jd_*) on all three levels

Java Driller (the team's tool, pipeline version, JavaParser 3.26.2) reads the source of every snapshot and records which project file uses which other project file (raw_jd_deps.csv in the run folder). From that list the same measures exist for a file, a module and the whole project:

Measure	File	Module	Project
outgoing dependencies	jd_fan_out	jd_dependencies (sum of its files)	jd_dependencies (all edges)
outgoing cross-module dependencies	jd_cross_module_deps: from this file into another module	jd_cross_module_deps: from its files into other modules	jd_cross_module_deps: all cross-module edges
incoming cross-module dependencies	jd_cross_module_in: from other modules into this file	jd_cross_module_in: from other modules into its files	jd_cross_module_in: all cross-module edges (= outgoing)
cross-module share	jd_cross_dep_share = cross-module out / fan-out	jd_cross_dep_share = cross-module out / dependencies	jd_cross_dep_share = cross-module edges / all edges
methods	jd_method_count	jd_method_count (sum)	jd_method_count (sum)
classes	jd_class_count	jd_class_count (sum)	jd_class_count (sum)
cohesion (1 / LCOM4)	jd_cohesion (mean over the file's classes)	jd_cohesion_mean (files weighted by ncloc)	jd_cohesion_mean (files weighted by ncloc)
classes measured for cohesion	jd_lcom4_classes	sum	sum
classes doing more than one job (LCOM4 > 1)	jd_noncohesive_classes	sum	sum
share of classes doing more than one job	jd_noncohesive_share	sum of non-cohesive / sum of measured	same, whole project
tests	jd_has_test (0/1)	jd_test_share (share of files)	jd_test_share (share of files)

File level only: jd_fan_in (project files that use this file), jd_external_class_count (classes in other files that use this file's classes), jd_coupling (distinct files linked either way).

• jd_cross_dep_share runs from 0 (every dependency stays inside the module: self-contained) to 1 (every dependency leaves it: tangled with other modules). Empty when there are no dependencies.
• Single-module repos (commons-io, java-websocket) have 0 cross-module dependencies by definition.
• Cohesion above file level: an average hides the bad classes, so two values are given. jd_cohesion_mean weights each file by its lines of code (a 5-line helper does not count as much as a 2,000-line core class - the same rule as the CK columns, paper sec. 4.2). jd_noncohesive_share counts classes: 0.20 = one class in five does more than one job.
• Cross-module dependencies of files add up exactly to modules and to the project (checked by validate.py).
• Where each measure comes from: LCOM4 - Hitz & Montazeri 1995; fan-in / fan-out - Henry & Kafura 1981 (doi 10.1109/TSE.1981.231113); coupling - CBO, Chidamber & Kemerer 1994 (doi 10.1109/32.295895); tests by name - Van Rompaey & Demeyer 2009 (doi 10.1109/CSMR.2009.39); cross-module dependencies - MacCormack, Rusnak & Baldwin 2006 (doi 10.1287/mnsc.1060.0552).
• Java Driller works on source code, CKJM on compiled classes: jd_fan_in / jd_fan_out / jd_coupling count files, CKJM's ck_Ca / ck_Ce / ck_CBO count classes. They overlap - check their correlation and keep the one that predicts better.

Flags and statuses explained

File identity over time: lineage_id, lineage_status, lineage_confidence

A file's path can change (renamed, or moved to another folder). lineage_id is one id for "the same file" in every snapshot, so its lags and targets follow it after a rename. Between two scanned snapshots we run git diff -M -C: git treats a deleted file and an added file as a rename when their contents are at least 50% similar.

lineage_status	Meaning (compared with the previous scanned snapshot)
NEW	the file appears for the first time: added, copied from another file, or in the run's first snapshot
UNCHANGED	same path, git shows no change
MODIFIED	same path, content changed
RENAMED	new path, but git matched it to an old file; it keeps the old file's lineage_id

lineage_confidence	Meaning
HIGH	the file's identity is clear
AMBIGUOUS	git says the file was copied from another file, or one old file was renamed into two or more new files (a split). We cannot say which new file "is" the old one. It stays AMBIGUOUS for the rest of the run, keeps all its features, but gets no targets (AMBIGUOUS_LINEAGE).

Example: Call.java moved from okhttp/src/main/java/com/squareup/okhttp/ to okhttp/src/main/java/okhttp3/ (okhttp 3.0) is RENAMED with the same lineage_id when git finds the two versions at least 50% alike, so target_td_3w of its last old-path row is read from its new-path row.

Module identity: module_lineage_status, module_lineage_confidence

Value	Meaning
CONTINUED (HIGH)	a module with this name existed in the previous snapshot
RENAMED (HIGH / MEDIUM)	a new name, but most of its files (by lineage_id) were in ONE other module before: HIGH when 80% or more, MEDIUM when 50-80%
NEW (HIGH / LOW)	a new module; LOW when some of its files existed elsewhere before but no single module gave half of them

Target status: target_td_3w_status, target_td_1m_status, target_td_3m_status

For a row at snapshot t and horizon h (3, 4 or 12 snapshots):

Status	Meaning	Target value
OBSERVED	snapshot t+h was scanned and the same project / module / file (same lineage_id) is in it	filled
BEYOND_RUN	t+h is after the last snapshot of the run (the last 3, 4 or 12 rows of every run)	empty
WEEK_NOT_SCANNED	t+h is in the plan but could not be measured (its build failed)	empty
ENTITY_GONE	t+h was scanned, but this module or file is not in it: it was deleted (a rename is NOT gone - it is followed)	empty
AMBIGUOUS_LINEAGE	file level only: the file was copied or split, so its future self cannot be identified	empty

Why the status matters (survivorship bias). If rows with an empty target are simply dropped, the deleted files (ENTITY_GONE) disappear from training without anyone noticing. Deleted files are often special (dead code, replaced classes), so the model would learn only from files that survived. Train on OBSERVED, report how many rows each status has, and decide on purpose what to do with the others (for example study ENTITY_GONE files separately). Nothing is filled in for you.

Other flags

Flag	1 means	0 means
has_ck	the file has CK values	no compiled class: package-info.java, Kotlin, or a class CKJM dropped
has_halstead	the file has Halstead values	the file could not be parsed as Java
is_package_info	the file is package-info.java (package docs only, no code, no TD)	an ordinary file
same_commit_as_prev_week	no new commit since the previous snapshot: the values just repeat	there is new code
sonar_history_ok_<N>d	a snapshot at least N days older exists, so the _<N>d SonarQube changes are filled	too early in the run: those cells are empty
file_deleted (META)	the file is gone in the next scanned snapshot. Future information - never an input	still there

days_since_prev_week is not 0/1: it is the real number of days since the previous kept snapshot (7 normally, 14 after one failed week).

History features, targets and roles (history.py)

• Every column has a role in data_dictionary.csv: ID, FEATURE, FLAG, META, TARGET. Train only on FEATURE (+ FLAG if useful). TARGET and META columns are never inputs.
• Targets: target_td_3w, target_td_1m, target_td_3m = total_principal of the same project / module / file 3, 4 and 12 weekly snapshots later. Use a target only where its *_status == OBSERVED. Missing targets are never filled.
• Week windows (td_*_lag, td_change_*w, td_slope_*w, td_volatility_4w) count weekly snapshots, like the paper's sliding window. Day windows (_21d, _30d, _90d, _180d) use real commit time: (t0 - N days, t0]. Nothing after t0 is ever read, except the targets and the META column file_deleted.
• SonarQube-based day-window changes compare t0 with the latest snapshot at least N days older; if there is none, the cell is empty and sonar_history_ok_<N>d = 0.
• Files are followed across renames (lineage_id). Group by lineage_id (file level) or module (module level) when making cross-validation folds, so one file never sits on both sides.
• Files whose identity is ambiguous (copied / split, lineage_confidence = AMBIGUOUS) get no targets.
• Git day-window features count main Java files (src/main/java, or src/java in old Apache projects), so they add up exactly file -> module -> project (commits are distinct commits, so module commit counts can add to more).
• CK metrics are LOC-weighted like the paper (sec. 4.2): the class values are averaged with each class's lines of code as the weight - at file, module and project level.
• Module-only: mod_avg_complexity, parent_module_id, afferent_coupling_ca, efferent_coupling_ce (from Java imports between modules), module_lineage_*.
• Function complexity (fn_*) is computed by parsing the source (1 + if/for/while/do/case/catch/?:/&&/|| per method); it is close to, but not identical with, SonarQube's own complexity.

Requested column names -> mart columns

One column per measure, with the same name at every level (filter by level); the names asked for map like this:

Asked for	In the mart
technical_debt_minutes_t0	total_principal
finding_count_t0	sonar_violations
file_cyclomatic_complexity	sonar_complexity (level=file)
file_lines_of_code	sonar_ncloc (level=file)
mod_lines_of_code	sonar_ncloc (level=module)
path_at_t0	path
file_lines_churned_{21,30,90,180}d	git_lines_churned_{N}d (level=file)
mod_lines_churned_{21,30,90,180}d	git_lines_churned_{N}d (level=module)
file_total_commits_{21,30,90,180}d	git_commits_{N}d (level=file)
file_major_author_commits	major_author_commits (level=file)
mod_knowledge_fragmentation	knowledge_fragmentation_180d (level=module)
Churn / Commit Burstiness	churn_burstiness_180d / commit_burstiness_180d
Function complexity distribution	fn_complexity_dist_{1,2,4,6,8,10,12} (+ fn_count, fn_complexity_max/mean)
Development cost	development_cost_t0
lineage_confidence / lineage_status (module)	module_lineage_confidence / module_lineage_status