instruction
stringclasses 1
value | input
stringlengths 45
20.4k
| output
stringclasses 8
values |
|---|---|---|
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: commit-messages)Fix typo (#934)
Fix missing word. "one **which** has too many states"
| Documentation |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: code-comments)// TODO: This creates a dependency on the Critics subsystem. // We need a generic way for modules (including our internal // subsystems) to request addition of actions to the popup // menu. - tfm 20080430
| Design |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: issues)This patch makes TBinaryProtocol use direct buffer access in the relevant methods. My performance testing was somewhat rudimentary, but I think it may have as much as doubled performance. Obviously your performance boost will be really dependent on the contents of your struct, but this seems pretty great. As a side effect of this issue, I refactored the TCompactProtocol test so that we could exact TBinaryProtocol to the same bevy of test cases.
| Code |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: issues)Removed directory layout reference from CompactionTool and moved it to The new tool named CompactionTool is added with changed interface. The new CT takes table, regions, column families as an input command line arguments. Both the legacy and new CT use APIs provided by MasterStorage/ RegionStorage classes. Map Reduce functionality of old CT is not yet implemented in the new CT as there are on-going discussions about it. Manually tested old CT and the new CT.
| Architecture |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: issues)Ensure at most one JVMPauseMonitor thread is running per JVM when there are multiple JVMPauseMonitor instances, e.g., in mini clusters. This will prevent redundant GC pause log messages while still maintaining one monitor thread running. This is a different way to fix HADOOP-12855.
| Design |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: code-comments)one exception: if there's more than one byte and the most
| Design |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: issues)Fixing this would make query gen testing easier.
| Design |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: code-comments)//TODO: proxies!
| Requirement |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: code-comments)errors
| Defect |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: issues)The standard is not hard and fast but it would be nice if a single approach was adopted, perhaps working around the mixed naming conventions in the API.
| Code |
There are eight types of self-admitted technical debts:
1.Architecture: Architecture Debts are caused by violations of modularity or using obsolete technology. In violations of modularity, because shortcuts were taken, multiple modules became inter-dependent, while they should be independent. In using obsolete technology, architecturally-significant technology has become obsolete.
2.Build: Build Debts are caused by over-or under-declared dependencies Under-declared dependencies mean dependencies in upstream libraries are not declared and rely on dependencies in lower-level libraries. Over-declared dependencies mean unneeded dependencies are declared.
3.Code: Poor deployment practice, Complex code, Duplicated code, Low-quality code, Multi-thread correctness, Slow algorithm. Complex code means Code has accidental complexity and requires extra refactoring action to reduce this complexity.Dead code means Code is no longer used and needs to be removed. Duplicated code means Code that occurs more than once instead of as a single reusable function. Low-quality code means Code quality is low, for example, because it is unreadable, inconsistent, or violating coding conventions. Multi-thread correctness means Thread-safe code is not correct and may potentially result in synchronization problems or efficiency problems. Slow algorithm means A non-optimal algorithm is utilized that runs slowly.
4.Defect: Defect Debts are caused by Uncorrected known defects, defects are found by developers but ignored or deferred to be fixed.
5.Design: Non-optimal design decisions are adopted.
6.Documentation: Documentation Debts are caused by Low-quality documentation or Outdated documentation. Low-quality documentation means the documentation has been updated reflecting the changes in the system, but the quality of updated documentation is low. Outdated documentation means a function or class is added, removed, or modified in the system, but the documentation has not been updated to reflect the change.
7.Requirements: Requirements Debts are caused by requirements partially implemented or non-functional requirements. Requirements partially implemented means requirements are implemented, but some are not fully implemented.Non-functional requirements means non-functional requirements (e.g. availability, capacity, concurrency, extensibility), as described by scenarios, are not fully satisfied.
8.Test: Expensive tests, Flaky tests, Lack of tests, Low coverage. Expensive tests means Tests are expensive, resulting in slowing down testing activities. Extra refactoring actions are needed to simplify tests. Flaky tests means Tests fail or pass intermittently for the same configuration. Lack of tests means A function is added, but no tests are added to cover the new function. Low coverage means Only part of the source code is executed during testing.
Self-admitted debts have four common sources : code-comments, issues, pull-requests, commit-messages.
Tell me which of the eight types the following technical debt belongs to?
| ### Technical debt text: (From: code-comments)XXX Can't do this simultaneously in multiple threads. Need
| Requirement |
Subsets and Splits