Datasets:

---

chaos1203

/

satd_aug

like 0

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)// FIXME:Elucidate the discrepancy between warn and warning in the documentation

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: should getenv logic be moved into find(). can generalize the use of rewriting keys many things, ex: get('somekey') -> some_key (camel case to snake case for json keys perhaps) getenv is a wrapper around os.getenv which replaces characters in the original key. this allows env vars which have different keys than the config object keys.

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)FIXME _skip_test should be used here (if we could)

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)/**_x000D_ * **FIXME*This function requires documentation.

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: issues)We do not fear Avro, but we must address its downstream dependencies. Assistance in identifying and testing these dependencies throughout the stack would be greatly valued.

Test

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 save or smth

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: issues)I've created a manual with a simple cover page. Please review it and let me know your feedback. Tomorrow, I plan to include a dynamic insertion of the version number.

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: issues)This part is triggering a Checkstyle warning: We can clean that up by changing to: I realize there are existing instances of empty statements like this in the class, but let's avoid introducing new instances. The mvninstall failure appears to be a side effect of something in the bats testing of the bash scripts. It's unrelated to this patch. Since you need to upload one more patch revision to address the Checkstyle warning, let's do one more test run and see if it happens again. If it does, then I'll follow up. The license check warning is caused by a test copying a file to a location that it shouldn't, which is then covered by the license check. I'll follow up separately on that.

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)No, there are no user-facing feature changes with this story; it is purely for code clean-up and does not affect behavior. However, documentation is required once the task is completed.

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)/**_x000D_ * The event to fire._x000D_ *_x000D_ * TODO:The event that should be fired.

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: issues)What makes this situation uncomfortable is that the alterations I made might have been responsible for triggering such a failure. To be extra cautious, I performed a new clone/installation of the Master branch and executed the same test again: unsurprisingly, it failed in the exact same manner.

Test

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: pull-requests)This will slow down this performance critical code.

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)TODO: add inheritance from Graph once implemented

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)push a json marshaller onto the stack. we can't marshal from the out- side because duktape can crash on large nestings and we can't catch c++ exceptions ourselves from go. todo(karalabe): yuck, why wrap?!

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: pull-requests)The way it has been implemented doesn't match the description given. Renaming it "docker" instead of "docker-build" could streamline the command input.

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)/**. * The Activity diagram.<p>. *. * TODO:Display NorthWest and SouthWest handles only on the leftmost swimlane.

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: issues)It makes the CODE harder the read.

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)Setting `Mypath` as a character string rather than a data frame in the line `Mypath<-data(PathDataFrameFinalColon` in the second CODE block renders it unsuitable for the extractor function.

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: code-comments)XXX Ensure to accept at least the name of the population.

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)not yet known to our peer but would connect, and send.

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: pull-requests)#1682: Enhance the test coverage part-4 : dubbo-common/src/main/java/com/alibaba/dubbo/common/status(store|threadpoolutils) modules. dubbo-common/src/test/java/com/alibaba/dubbo/common/utils/UrlUtilsTest.java. XXXXEnhance the test coverage in dubbo-common/src/test/java/com/alibaba/dubbo/common/utils/UrlUtilsTest.java.

Test

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 test has been stable for a while. It's now taken out of TestExpectations.

Test

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:It is essential to conduct comprehensive testing on the indexing.

Test

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)Upon the first TESTs execution, it was observed that the expectations for "ex2" all failed.

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: code-comments)// TODO:Loading all classes at startup time is a performance inefficiency. They should be lazily loaded when required by implementing a method to identify specific classes to load.

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)//TODO: check that entry.getIdentifier().equals(requestedId)

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: commit-messages)GEODE-5036: Modify default for "enable-chunk-handler-thread" to "false" (#292). * Implemented new integration test for chunk handler feature. * Deleted test that was not useful. * Updated from 'disable-chunk-handler-thread' to 'enable-chunk-handler-thread'.

Test

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(rstambler): check the message of the actual error? it differs between $gopath and module mode.

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)MacPorts requires specific directives for packages to include dependencies, highlighting the importance of deactivating Qt support to prevent unexpected Qt4 detection.

Build

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)/**_x000D_ * Register an attribute declaration for later retrieval._x000D_ * Format:_x000D_ * - String type_x000D_ * - String default value_x000D_ * - int value type_x000D_ * *TODO: do something with attribute types._x000D_ */

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: pull-requests)Undoubtedly, it is vital to ensure the inclusion of licenses and notices for all transitive dependencies.

Build

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)/**_x000D_ * This class manages the windows for the application._x000D_ *_x000D_ * TODO:The rationale was that Sessionmanager would act as the controller._x000D_

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)Connection profile does not exist failure.

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: code-comments)/**_x000D_ * Builds an interface with a given name._x000D_ *_x000D_ * @param name is the given name._x000D_ * @return Interface_x000D_ * TODO: This needs an extra parameter to specify the model/extent where_x000D_ * the new element should be created._x000D_ */

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)Do not have direct dependencies on log4j for components in the 'test' scope, as it is transitive through the slf4j-log4j12 dependency with the appropriate version.

Build

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).NET: Improve exception messages for binary misconfiguration and missing assemblies

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: pull-requests)The presence of test flakiness is considered a form of technical debt.

Test

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: check invalid ips todo: check invalid unsigned record

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)As the delay is deemed intolerable, it is unattainable to introduce a solution that works across all platforms. Therefore, if an animation is desired, the current approach is deemed appropriate but requires execution on OS X and Linux.

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: issues)Is it preferable to sample two different names from the last names vector and then concatenate them instead?

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)// TODO: should the constraint name simply be the column name or something more like a constraint // name?

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)/**_x000D_ * Gets the location of an external commandline tool._x000D_ * <p>_x000D_ * TODO:Retrieve the external tool's location.

Test

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)Enable test coverage for Parquet gzip inserts was disabled

Test

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)The invalidlock is utilized to safeguard the invalidcount.

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: pull-requests)@ijuma Do you mean adding it to the comments or update the ticket description? I did not test Java 1.7 CRC32 performance. I only tested the one we used to use and the CRC32 performance in Java 1.8.

Test

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)Concerning the dependency on Progress OpenEdge, it is restricted to their customers necessitating guidelines for packaging and deployment within SMX. I plan to tackle the unit tests and the Apache License concerns immediately.

Test

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:Plans: Experiment

Test

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:Requirement pending: add metadata

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)/**_x000D_ * The event to fire._x000D_ *_x000D_ * TODO:The event that requires firing.

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: commit-messages)A cast kernel has been developed for most Arrow types in Rust.

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)// TODO: Shouldn't we do something here?

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: issues)My observation about Rccp dependencies stemmed from encountering a failed installation while repeatedly reinstalling the package during testing.

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: code-comments)TODO:Remove this entry.

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)/*_x000D_ * TODO: Is this needed/correct?_x000D_ * For when all compartments are hidden?_x000D_ */

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)Now, the RowResultGenerator and the will fit the column family if the request doesn't contain any column info. The will cost 10+ milliseconds in our hbase cluster each request. We can remove these code because the server will auto add the columns.

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: commit-messages)Disengage two unreliable tests (BEAM-8035, BEAM-9164).

Test

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: Add implementation. */

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)TODO:Task: Create a test specifically for ignore_sep=False.

Test

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)To ensure safety for multiple threads

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: issues)The API you are suggesting to use is marked deprecated below in the patch, So we should suggest to use in the first place also. also There is reference to this method in java doc of other public APIs to use this one, I suggest to remove their also and point it to actual API we would like user to use. General practice what I follow is when ever I mark a API as deprecated I replace all of its reference from the code with the one we are suggesting to use in the java doc. If you also want to do this please also take care of the references in ruby scripts...

Documentation