Software Development - CRASH COURSE

Abstraction

Considering product implementation at a higher level first, rather than concerning oneself with implementation at a detailed level, in order to access a problem area gradually while maintaining a larger flow.

Acceptance test

An acceptance test performed by the customer before release.

Actor

A classification of stakeholders into homogeneous groups according to their roles in relation to a system.

Activity diagram

A diagram used to accurately understand the process of handling events in a class, or to identify additional operations of a class.

Adjacency List

A graphing method using a linked data structure where nodes are connected as many times as the sequence number of each vertex using a simple linked list created by connecting adjacent vertices for each vertex.

Adjacency matrix

A method of graphing using a sequential data structure where the presence of the edge connecting two vertices of the graph as a matrix is stored in a matrix by using a two-dimensional array for the matrix.

Agile methodology

A software development methodology that aims to effectively respond to rapid changes in the market environment.

Algorithm

A description of a series of processing procedures used to solve a given problem by stages. It is a specification that logically describes a step-wise procedure by abstracting the problem-solving method.

Amount of fixed space

Storage space that is needed permanently, regardless of the program size or number of input/output times, such as programs, variables, constants, etc.

Amount of variable space

Storage space that stores data and variables used while executing a program, and information related to function execution.

Angular4

A JavaScript framework developed by Google, used for single-page application programs that responds to user requests quickly by extending the HTML DOM.

Apache license

An open-source license applicable to all software of the Apache Software Foundation (ASF) that does not require disclosure of the source code.

Application Lifecycle Management (ALM)

A system that detects changed codes, manages the changes, and supports build/distribution comprehensively, often integrated with performance management tools.

Architecture design

The process of identifying the composition of a system and how its components interact with each other at the beginning of the design process.

Assembly language

A low-level language that expresses machine language in simple characters.

Baseline

Technical control points of each configuration item; the standard point in time that controls all changes.

Binary search

A search method that sets the upper limit value (F) and the lower limit value (L), finds the intermediate value (M), and searches by continuously comparing the key and the intermediate value.

Black box testing

Also called function or specification-based testing, it is mainly used in system testing to verify both functional and non-functional requirements based on the specification without referring to the internal structure.

Breadth First Search (BFS)

A graph search algorithm where adjacent nodes are searched first after visiting one starting vertex; vertices adjacent to the start vertex are visited first, and vertices situated farther away are visited later.

BSD (Berkeley Software Distribution) license

A representative open software license that does not require the developer to disclose the software source code.

Bubble sort

A sorting algorithm where the largest element is continuously moved to the last position by comparing adjacent numbers and changing positions if they are not in order.

Builder pattern

A creation design pattern used when the returned objects are not simple inheritance targets but are completely different user interfaces composed of different combinations of objects.

Burndown chart

A deliverable in the Scrum process that shows remaining work in the sprint backlog, typically indicating remaining work for each iteration as a story point.

C language

A programming language developed by Dennis Richie at AT&T’s Bell Lab in the 1970s, known for fast execution and efficient memory management.

C++ language

A programming language suitable for system programming and object-oriented programming, supporting classes, operator overloading, and virtual functions.

CASE tools

Computer-Aided Software Engineering tools.

Class

A collection of similar objects. A set of objects having the same property.

Class diagram

An information model in UML that shows the static information structure of a system, representing the classes required for the system and the relationships between them.

Class pattern

A design pattern that handles the correlation between classes and subclasses, mainly through inheritance, determined statically at compile time.

Client-server model

A software architecture composed of a set of servers and clients, where the client requests a service and the server provides the service.

Code smell

Code that is difficult to read, has duplicated logic, or is otherwise hard for developers to maintain, indicating a need for refactoring.

Cohesion

A measure of module maturity that indicates the strength of the correlations among the internal modules. It indicates how each of the components in the module is correlated with the others in order to achieve a common purpose.

Coincidental cohesion

The lowest degree of cohesion, wherein a module is composed of unrelated processing elements.

Command pattern

A behavioral design pattern where a request is sent to a specific object, including a request for a specific processing task, using a known public interface.

Common coupling

Coupling in which several modules share a common data area.

Communication cohesion

Cohesion where components performing different functions while using the same input and output are gathered.

Compilation

Converting a specific language into another language having an equivalent meaning.

Compiler

Translates a high-level language into a machine language (a low-level language) to make an object module, which is then linked, loaded, and executed.

Complete graph

A graph that has as many edges as possible by connecting all the vertices with each other on the graph.

Component

A reusable part that can be purchased from other fields and plugged in to speed up software development and increase productivity.

Configuration audit

A configuration management activity that means determining the integrity of the software baseline.

Configuration control

A configuration management activity that involves reviewing and approving a software configuration change request and controlling it so that it can be reflected in the defined baseline.

Configuration identification

A configuration management activity that involves identifying a configuration management target and numbering the management items.

Configuration item

The default target that is formally defined and described in the software life cycle.

Configuration product

The tangible and realized target of configuration management that is formally implemented in the software development life cycle.

Configuration recording

A configuration management activity that involves recording the various statuses and execution results of software configuration and change management, and creating reports by managing the database.

Context model

A model that sets the boundary between the initial requirements analysis system and the external environment, representing the system as a large process before dividing it.

Continuous Integration (CI)

A software development activity that frequently integrates the results of a team composed of several members, involving automated build and testing before merging code changes to a central repository.

Control Coupling

Coupling in which a control element (function code, switch, tag, flag) used to control a logical flow is transferred from one module to another.

Control flow testing

A test design technique where all possible event flow (path) structures can be tested when executed using a component or system.

Coupling

The complexity of correlations between modules.

Creation pattern

A design pattern involved in the process of object creation.

Daily build

The process of comprehensively compiling software products again every day and running a series of tests to verify basic operation.

Data abstraction

A type of abstraction focusing on data.

Data coupling

Coupling when the interface between modules is composed of data elements only. This is the most ideal and weakest coupling.

Data flow-oriented design

The process of transferring the results of structured analysis, a functional modeling technique, to structured design.

Data structure

A method of storing data in the memory device of a computer. It defines data systematically so that various data can be efficiently expressed and utilized, considering the characteristics and usages of data.

Decision table testing

A test case design technique that tests the combination of input values indicated in the decision table and the stimuli (cause).

Decorator pattern

A structural design pattern used to dynamically add a function to a specific object or to delete the added function.

Deep first search (DFS)

A graph search algorithm that starts at the root node and explores in one direction of the starting vertex as far as possible; when there are no more places to go, it backtracks to the vertex with the last forked edge and continues to explore another direction.

Dependency Inversion Principle (DIP)

A design principle stipulating that design should be made as flexible as possible through abstraction using an interface to minimize the possibility of changes when the interface of a used class is changed.

Depth First Search (DFS)

An algorithm that starts at the root node and explores in one direction of the starting vertex as far as possible.

Design pattern

A general, reusable solution to a recurring problem in a specific context of software design. It is a description or a sample of a problem-solving method that can be used in various situations.

Directed graph

A graph whose connection lines are directional, where the sequence of vertices expressed in pairs is important.

Divide and Conquer

A basic design principle involving continuously dividing user requirements to reduce complexity and reassembling the results into proper groups.

Docker

An open-source platform that automates Linux container (LXC) technology for ease of use, providing an independent and isolated space like a virtual machine.

Dynamic modeling

A process of finding the operations of classes by paying attention to changes to the state or operations of the objects constituting the system, or the interactions between objects.

Dynamic viewpoint

A modeling viewpoint that describes the state of the system and the causes of changes (event, time, etc.) in its state by focusing on the operation and control of software.

Encapsulation

A method of obtaining improved abstraction and independence through information hiding, and a method of protecting properties and operations together as a group.

Equivalence partitioning

A test case design technique where a test is performed with the representative value placed in an equally divided area.

Evolutionary model

A software lifecycle model useful when system development time needs to be reduced, where the development phase for the entire system is reiterated several times, and each system provides all functions to the user.

Exhaustive testing

Testing all possible cases of a program.

Express.js

A small and flexible web application framework for Node.js that provides optimal features for developing web applications.

External coupling

Coupling in which data (variables) declared externally by one module are referenced by another module.

External sorting

A method of sorting a large volume of data in an auxiliary storage device.

Facade pattern

A structural design pattern that enables a user to receive a desired function using a representative class when several classes have a close relationship and play a role as a whole, without external clients directly handling each class.

Factory Method pattern

A creation design pattern that indirectly creates an object using a proxy function, rather than directly calling the object constructor.

Feedback (UI)

The user interface should provide meaningful feedback when a user performs an action, correctly or incorrectly.

Fibonacci search

A search method that creates sub-files using Fibonacci permutations, searching by addition and subtraction only.

Framework

A support unit that collects knowledge, which can be reflected in architectural design repetitively, when designing a subsystem. It represents a general structure that can be extended to create a concrete subsystem.

Functional cohesion

The highest degree of cohesion, wherein all elements of the module perform a single function for the upper-level module.

Functional viewpoint

A modeling viewpoint that describes a system from the viewpoint of the functions performed by software.

Generalization

The process of collecting similarities between classes to define a new class (superclass).

Generality (software reuse)

The principle that software should be generally reusable, rather than designed for a specific area of application.

Git

A distributed version control system where clients copy the entire repository, allowing server restoration from client copies if issues occur.

GPL (GNU General Public License) 2.0

The most frequently adopted open-source software license, created by the Free Software Foundation (FSF), known for its strictness.

GPL (GNU General Public License) 3.0

An updated version of GPL 2.0, supplemented with matters related to DRM, software patent issues, and compatibility issues.

Graph

A data structure that expresses the many-to-many relationship between connected elements; a set of vertices that represent objects and the edges that connect those objects.

Hardware independence (software reuse)

The principle that reused software should be independent of execution hardware as much as possible.

Hashing

A search method that searches for data by calculating the address where they are stored using a hashing function.

High-level language

A programming language that is easy to write, highly readable and productive, similar to natural language, and can be converted into low-level language by a compiler or interpreter.

Hierarchy (software architecture)

A system composed of several layers that provide its own specific service.

Incoming flow

In transform flow-oriented design, a set of processes that manages input.

Incremental model

A software lifecycle model useful when system development time needs to be reduced, where core parts are developed first to make the system operable, and then the rest of the functions are implemented.

Information hiding

A design principle where the content of each module is hidden, and messages can be transmitted by the interface only, limiting access to internal information so that one module or subsystem does not affect others.

Information modeling

The process of identifying information that should be saved and managed inside the system, displayed as a class diagram in UML.

Information viewpoint

A modeling viewpoint used to understand the static information structure of software by finding information objects, their characteristics, and relationships.

Inheritance

A characteristic of object-oriented programming where a new class (subclass) can be created by reusing and extending the properties and operations of an existing class (superclass).

Input (algorithm condition)

More than one data that are needed to execute an algorithm should be entered from outside.

Insertion sort

A sorting method that sorts by inserting a value into the concerned position based on the assumption that data has been sorted.