This glossary describes the major terms as we have used them within the context of this book.

Agile Data (AD) method

A collection of philosophies and roles for defining how data-oriented development activities can be applied in an agile manner.

Agile Model-Driven Development (AMDD)

A highly iterative approach to development in which you create agile models before you write source code.

Agile Modeling (AM)

A chaordic, practices-based methodology that describes how to be effective at modeling and documentation.

Agile software development

An evolutionary and highly collaborative approach to development in which the focus is on delivering high-quality, tested software that meets the highest-priority needs of its stakeholders on a regular basis.

Agile Unified Process (AUP)

An instantiation of the Unified Process (UP) that applies common agile practices such as database refactoring, Test-Driven Development, and Agile Model-Driven Development.

Architectural refactoring

A change that improves the overall manner in which external programs interact with a database.

Artifact

A document, model, file, diagram, or other item that is produced, modified, or used during the development, operation, or support of a system.

Behavioral semantics

The meaning of the functionality implemented within your database.

Code smell

A common category of problem in your source code that indicates the need to refactor it.

Conceptual/domain model

A model that depicts the main business entities and the relationships between them, and optionally the attributes or responsibilities of those entities.

Coupling

A measure of the dependence between two items; the more highly coupled two things are, the greater the chance that a change in one will require a change in another.

Crystal

A self-adapting family of “human-powered” agile methodologies developed by Alistair Cockburn.

Data access object (DAO)

A class that implements the necessary database code to persist a corresponding business class.

Database refactoring (noun)

A simple change to a database schema that improves its design while retaining both its behavioral and informational semantics—in other words, you can neither add new functionality nor break existing functionality, nor can you add new data nor change the meaning of existing data.

Database refactoring (verb)

The process by which you evolve an existing database schema a small bit at a time to improve the quality of its design without changing its semantics.

Database regression testing

A process in which you ensure that the database schema actually works by developing and then regularly running a test suite against it.

Database schema

The structural aspects, such as table and view definitions, and the functional aspects, such as database methods, of a database.

Database smell

A common problem within a database schema that indicates the potential need to refactor it.

Database transformation

A change to your database schema that may or may not change the semantics of the schema. A database refactoring is a kind of database transformation.

Data definition language (DDL)

Commands supported by a database that enable the creation, removal, or modification of structures (such as relational tables or classes) within it.

Data manipulation language (DML)

Commands supported by a database that enables the access of data within it, including the creation, retrieval, update, and deletion of that data.

Data quality refactoring

A change that improves the quality of the information contained within a database.

Demo sandbox

A technical environment into which you deploy software to demonstrate it to people outside of your immediate development team.

Deployment window

A specific point in time during which it is permissible to deploy a system into production. Often called a release window.

Deprecation period

See Transition period.

Development sandbox

A technical environment in which IT professionals write, test, and build software.

Dynamic System Development Method (DSDM)

An agile method that is a formalization of the Rapid Application Development (RAD) methods of the 1980s.

Enterprise Unified Process (EUP)

An extension to the Rational Unified Process (RUP) which addresses the cross-project/system needs.

Evolutionary data modeling

A process in which you model the data aspects of a system iteratively and incrementally, to ensure that the database schema evolves in step with the application code.

Evolutionary software development

An approach in which you work both iteratively and incrementally.

Extract-transform-load (ETL)

An approach to moving data from one source to another in which you “cleanse” it during the process.

Extreme Programming (XP)

A disciplined and deliberate agile development method that focuses on the critical activities required to build software.

Feature-Driven Development (FDD)

An agile development method based on short iterations that is driven by a shared object domain model and features (small requirements).

Incremental software development

An approach to software development that organizes a project into several releases instead of one “big-bang” release.

Informational semantics

The meaning of the information within the database from the point of view of the users of that information.

Iteration

A period of time, often a week or two, during which working software is written. Also called a development cycle.

Iterative software development

A nonserial approach to development in which you are likely to do some requirements definition, some modeling, some programming, or some testing on any given day.

Method

Within a database, a stored procedure, stored function, or trigger.

Method refactoring

A change to a method that improves its quality. Many code refactorings are applicable to database methods.

Model storming

A short burst of modeling, often 5 to 15 minutes in duration, in which two or more people work together to explore part of the problem or solution domain. Model storming sessions are immediately followed by coding sessions (often several hours or days in length).

Multi-application database

A database that is accessed by several applications, one or more of which are outside the scope of your control.

Object-relational mapping (ORM)

The definition of a relationship(s) between the data aspects of an object schema (for example, Java classes) and a relational database schema.

Production environment

The technical environment in which end users run one or more systems.

Production phase

The portion of the system life cycle where the system is run by its end users.

Project integration sandbox

A technical environment where the code of all project team members is compiled and tested.

Rapid Application Development (RAD)

An approach to software development that is highly evolutionary in nature that typically involves significant amounts of user interface prototyping.

Rational Unified Process (RUP)

A rigorous, four-phase software development process created by IBM Rational that is evolutionary in nature.

Refactoring (noun)

A simple change to source code that retains its behavioral semantics: You neither add functionality when you are refactoring nor take it away. A refactoring merely improves the design of your code—nothing more and nothing less.

Refactoring (verb)

A programming technique that enables you to evolve your code slowly over time, to take an evolutionary approach to programming.

Referential integrity

The assurance that a reference from one entity to another entity is valid. If entity A references entity B, entity B exists. If entity B is removed, all references to entity B must also be removed.

Referential integrity refactoring

A change that ensures that a referenced row exists within another table and/or ensures that a row that is no longer needed is removed appropriately.

Regression test suite

A collection of tests that are run against a system on a regular basis to validate that it works according to the tests.

Sandbox

A fully functioning environment in which a system may be built, tested, and/or run.

Scrum

An agile method whose focus is on project management and requirements management. Scrum is often combined with XP.

Serial development

An approach in which fairly detailed models are created before implementation is “allowed” to begin. Also known as waterfall development.

Single-application database

A database that is accessed by a single application that is “owned” by the same team that owns the database.

Standup meeting

A short meeting that is held with team members standing up and giving status reports on tasks they did yesterday and plan to do today, problems they faced, architecture they changed, and other important things that need to be communicated to the team.

Stereotype

A UML construct that denotes a common use of a modeling element. Stereotypes are used to extend the UML in a consistent manner.

Structural refactoring

A change to the definition of one or more tables or views.

Test-Driven Development (TDD)

The combination of TFD and refactoring.

Test-First Development (TFD)

An evolutionary approach to development in which you must first write a test that fails before you write new functional code so that the test passes. This is also known as Test-First Programming.

Transaction

A single unit of work that either completely succeeds or completely fails. A transaction may be one or more updates to an object, one or more reads, one or more deletes, one or more insertions, or any combination thereof.

Transition period

The time during which both the old schema and the new schema are supported in parallel. Also referred to as a deprecation period.

Trigger

A database method that is automatically invoked as the result of Data Manipulation Language (DML) activity within a persistence mechanism.

Unified Modeling Language (UML)

The definition of a standard modeling language for object-oriented software, including the definition of a modeling notation and the semantics for applying it, as defined by the Object Management Group (OMG).

Waterfall development

See Serial development.

XUnit

A family of unit testing tools, including JUnit for Java, VBUnit for Visual Basic, NUnit for .NET, and OUnit for Oracle.