| ... |
... |
@@ -2,7 +2,7 @@ |
| 2 |
2 |
|
| 3 |
3 |
| -------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |
| 4 |
4 |
| **Term** | **Explanation** | |
| 5 |
|
-| Abstraction | 1) The counterpart of 'concreteness', it refers to interfaces and abstract classes that define behavior (function signatures) but leave the internal implementation of those functions undefined. 2) A higher-level, generalized unit of code. Duplication across multiple functions can be resolved by creating an 'abstraction' - a separate function containing the shared code. This adheres to the DRY principle. | |
|
5 |
+| Abstraction | 1) The counterpart of 'concreteness', it refers to interfaces and abstract classes that define behavior (function signatures) but leave the internal implementation of those functions undefined. 2) A higher-level, generalized unit of shared code. Duplication across multiple functions can often be resolved by creating an 'abstraction' - an additional function containing the duplicated code. | |
| 6 |
6 |
| [[Acceptance Test|doc:Software Engineering.Agile.Extreme Programming.Acceptance Tests.WebHome]] | See link. | |
| 7 |
7 |
| [[Agile|doc:Software Engineering.Agile.WebHome]] | See link. | |
| 8 |
8 |
| Assertion | An assertion function, a crucial part of testing. If the input values don't satisfy a certain condition, the test containing the assertion fails. Example: `assertEquals(expectedResult, actualResult)`. | |
| ... |
... |
@@ -12,7 +12,7 @@ |
| 12 |
12 |
| Business | Non-technical decision makers in the organization developing the software. | |
| 13 |
13 |
| Business Value | The worth of a feature in terms of its benefit to the business. | |
| 14 |
14 |
| Compile Time | The period when the code is compiled. Often used to distinguish from runtime. | |
| 15 |
|
-| Concretion | The counterpart to 'abstraction', also known as 'implementation'. In OOP, refers to non-abstract classes that implement the methods of interfaces or abstract classes. A concretion provides the 'concrete' code defining the workings of these abstract functions. | |
|
15 |
+| Concretion | The counterpart to 'abstraction'. Concretion is also known as 'implementation'. In OOP, it refers to non-abstract classes that implement the methods of interfaces or abstract classes. A concretion provides the 'concrete' code defining the workings of these abstract functions. | |
| 16 |
16 |
| [[Constructor Injection|doc:Software Engineering.Architecture.Dependency Injection.Types of Dependency Injection.WebHome]] | A type of dependency injection in which dependencies are provided to an object through constructor arguments. | |
| 17 |
17 |
| Command-Line Interface (CLI) | "[...] a means of interacting with a computer program by inputting lines of text [...]".^[[src](https://en.wikipedia.org/wiki/Command-line_interface)]^ For example, tools/commands used when working with a (Linux) terminal. | |
| 18 |
18 |
| Commitment | Binding promise to complete a specific task within a set period of time. | |
| ... |
... |
@@ -46,10 +46,12 @@ |
| 46 |
46 |
| Magic | Code that performs complex tasks while abstracting away the complexity, presenting a simple interface to the user. | |
| 47 |
47 |
| Manager | Individuals responsible for planning, organizing, leading, and controlling a software project's resources, schedule, and deliverables to meet stakeholder expectations. | |
| 48 |
48 |
| Operating System (OS) | The foundational system software that manages and coordinates all computer resources. Examples are Windows, MacOS and Linux. | |
|
49 |
+| Overloading | Some programming languages offer the feature of overloading, which means that two operators with the same name can still be distinguished if they have different signatures. For example, these two functions are overloaded: `tripleNumber(n: float)` and `tripleNumber(n: int)`. | |
| 49 |
49 |
| Pain | An unpleasant experience caused by unnecessary efforts that could have been mitigated with better design of the original code. | |
| 50 |
50 |
| [[Pair Programming|doc:Software Engineering.Agile.Extreme Programming.Pair Programming.WebHome]] / Pairing (up) | See link. | |
| 51 |
|
-| Physical | Counterpart to logical. Refers to hardware. For example, physically deleting a file means removing it from the disk. | |
|
52 |
+| Physical | The counterpart to "logical". Refers to hardware. For example, physically deleting a file means removing it from the disk. | |
| 52 |
52 |
| Points / Story Points | A unit of measure used to estimate the effort required to complete a user story. See also [[here|doc:Software Engineering.Agile.Extreme Programming.Planning Game.Effort Estimation.WebHome]]. | |
|
54 |
+| Problem Domain | The language/terminology used to describe the software requirements ("the problems") from the perspective of non-technical stakeholders. | |
| 53 |
53 |
| Production Code | Code that comprises the functioning part of an application, as opposed to test code. | |
| 54 |
54 |
| Programmer | Someone who writes and tests code. The knowledge level of a beginner. | |
| 55 |
55 |
| Requirement | Statement of what a software must be capable of doing, often outlining features, constraints, and success criteria. | |
| ... |
... |
@@ -65,6 +65,7 @@ |
| 65 |
65 |
| [[Setter Injection|doc:Software Engineering.Architecture.Dependency Injection.Types of Dependency Injection.WebHome]] | A type of dependency injection where a dependency is provided to an object through a setter method. | |
| 66 |
66 |
| Snapshot | A saved state of a system or data at a specific point in time. Can be used for rollbacks. | |
| 67 |
67 |
| Software Engineer | Technical expert with in-depth knowledge in many areas, including high-level topics such as software architecture and system design. | |
|
70 |
+| Solution Domain | The language/terminology used by technical experts to describe the technical solutions to the software requirements described by the problem domain. | |
| 68 |
68 |
| Specification | A detailed description of the requirements under which a user story is considered complete. Much more detailed than the original user story. | |
| 69 |
69 |
| Stakeholders | Individuals with an interest in the success of a software project, which may include customers, developers, investors, externals and others who are affected by the projects outcome. | |
| 70 |
70 |
| Static | Behaviors/properties determined before or at compile time. Examples: static code analysis tools inspect source code; statically-typed languages determine an object's type at compile time. | |
| ... |
... |
@@ -76,6 +76,7 @@ |
| 76 |
76 |
| Test Code | Code that tests the functionality of production code. Does not contribute to the operational aspects of an application. | |
| 77 |
77 |
| Test-Driven Development (TDD) | A development approach where code is written in small increments, with tests defining functionality written at the beginning of each coding iteration. | |
| 78 |
78 |
| Test Suite | The sum of all the test code used to check that a system meets its requirements. | |
|
82 |
+| Testability | Code is testable, or has good testability, if it is easy to write tests for. | |
| 79 |
79 |
| Unit | The smallest testable part of an application. This is often a single class, but can also be a single function, or a small cluster of tightly coupled classes or functions that together perform a specific task. | |
| 80 |
80 |
| [[Velocity|doc:Software Engineering.Agile.Extreme Programming.Planning Game.Agile and Data.WebHome]] | See link. | |
| 81 |
81 |
| Virtual Machine (VM) | A software emulation of a physical computer, able to run its own OS and applications as if it were a separate physical machine. | |
