What you will learn in Data-Oriented Programming in Java
Chapter by chapter
Chapter 1: Data Oriented Programming
The introduction defines the book’s data-oriented programming approach: represent domain meaning as well-typed, immutable data rather than relying on code alone to convey it.
What you learn in chapter 1 →Chapter 2: Data, Identity, and Values
Introduces the chapter’s plan to explore representing data as data in Java, including entities that change over time.
What you learn in chapter 2 →Chapter 3: Encoding Semantics in the Type System
The chapter introduction argues that understanding what data means is a foundation for building reliable systems before representing that meaning in code.
What you learn in chapter 3 →Chapter 4: Domain Modeling with Algebraic Data Types
The chapter introduces an iterative design approach that focuses on domain data and its meaning before operational or system-level concerns.
What you learn in chapter 4 →Chapter 5: Modelling Domain Behaviors
Introduces the chapter’s plan to apply data-oriented modeling to a complex feature within an existing application.
What you learn in chapter 5 →Chapter 6: Implementing the Domain Model
The chapter introduction explains why implementing the invoicing domain model requires care with Java methods and decisions about code organization.
What you learn in chapter 6 →Chapter 7: Reasoning About Correctness
The introduction proposes algebraic reasoning about values and their relationships as a way to judge whether code is simpler.
What you learn in chapter 7 →Chapter 8: Business Rules as Data
The chapter introduces data as a starting point for modern Java design, contrasting it with Java’s reputation for inheritance-heavy abstractions.
What you learn in chapter 8 →Chapter 9: Refactoring Legacy Code
The introduction frames data-oriented refactoring as a way to improve ordinary legacy code incrementally by bringing its hidden data to the surface.
What you learn in chapter 9 →Chapter 10: Data Oriented Architecture
The introduction frames data-oriented architecture as an approach in which objects serve as gatekeepers for exchanging data.
What you learn in chapter 10 →Chapter 11: Data Oriented Testing
The chapter introduces data-oriented testing and emphasizes that how tests represent data affects their clarity.
What you learn in chapter 11 →Chapter 12: Integration Testing
The introduction explains why integration tests matter for software that interacts with the world and why they are difficult to make reliable.
What you learn in chapter 12 →Concepts explained in this book
- data typeA data type is a classification of data that determines its representation, permitted values, and valid operations.
- data-oriented programmingData-oriented programming is a programming approach that organizes software around explicit data representations and operations on those representations.
- invariantAn invariant is a condition that must remain true across the valid states of a data structure or computation.
- semanticsSemantics are the intended meanings that a program expresses through its data and operations.
- dataData is information represented independently of the behaviors that operate on it.
- illegal stateAn illegal state is a program state that violates the validity constraints imposed by its data model or domain rules.
- algebraic operationAn algebraic operation is a rule for combining elements of specified sets to produce an element of a specified result set.
- algebraic lawAn algebraic property is a characteristic describing how an operation behaves under operand order, grouping, and relationships between inputs and outputs.
- functionA computation that maps input values to an output value or values without requiring mutation of the input values.
- integration testIntegration testing evaluates interactions between multiple software components or external dependencies.
- data modelingData modeling is the design process of identifying domain information, its meaning, and its representation.
- randomizationRandomization is the generation or selection of varying test inputs to exercise a broader range of program states than fixed examples.
- determinismA deterministic function is a computation whose output is completely determined by its inputs and remains consistent for repeated evaluations with those inputs.
- test suiteA test suite is a collection of automated or executable tests that assess software against specified expectations.
- optionOptional is the Java container class that represents either a present non-null value or the absence of a value.
- mutationMutation is the modification of an existing program value or state in place.
- software testingTesting is the practice of executing checks that assess whether software behaves according to specified expectations.
- refactoringRefactoring is the restructuring of existing software without changing its externally observable behavior.
- business ruleA business rule is a domain constraint or policy that determines valid actions, states, or outcomes.
- lifecycleA lifecycle is the sequence of states and changes an entity undergoes over the course of its existence.
- validationValidation is the process of checking data and system conditions against the preconditions required for safe continuation.
- pure functionA pure function is a computation that produces the same output for the same inputs without observable side effects or dependence on mutable external state.
- accuracyCorrectness is the property that an implementation produces the behavior and results specified by its intended semantics and requirements.
- union typeA sum type is a type formed by combining alternative types with OR semantics so that a value belongs to one of several permitted variants.
- type safetyType safety is the property that a programming language or program prevents operations from being applied to values of incompatible types.
- algebraic data typeAn algebraic data type is a composite type whose values are formed by combining product and sum alternatives of other types.
- setA set is a collection that represents distinct elements without treating duplicate occurrences as separate members.
- decision makingA decision is a modeled choice among alternative outcomes or actions based on available information.
- identityObject identity is the property that distinguishes an object from other objects regardless of its current data values.
- constraintA constraint is a condition that restricts which data representations or program states are valid.
- binary operationA binary operation is a rule that takes exactly two operands from a specified set or type and produces a result.
- product typeA product type is a type whose values combine one value from each of several component types, corresponding to logical AND and a Cartesian product.
- value objectA value object is an object that represents an immutable value and is distinguished by equality of its properties rather than by object identity.
- wrapperA wrapper is a type or software component that encloses another representation or interface and exposes a deliberately shaped semantic interface around it.
- missing valueA special Java reference value indicating the absence of an object rather than an instance of the referenced type.
- data transformationData transformation is the process of producing successive data states by changing or converting an existing representation.
- data as dataData as data is the representation of information as ordinary, openly accessible values rather than as hidden private object state.
- semantic driftSemantic drift is the gradual divergence of a program’s interpretation of data or state from its intended meaning.
- assertionAn assertion is an executable check that a specified condition holds for a value, state, or computation.
- stateThe data values that describe the current condition of an object or entity.
- semantic integritySemantic integrity is the property of a program whose data meanings and valid states are explicitly represented and consistently enforced.
- functional coreThe deterministic core is the central part of an application containing domain logic whose results do not depend on side effects or nondeterministic interactions.
- test data generationA test data generator is a mechanism that produces input values or cases for testing software according to defined generation rules.
- factoryA factory function is a function that constructs and returns an instance or structured test datum through a defined parameter interface.
- valueA value is information whose meaning is determined by its contents rather than by the identity of the object carrying it.
- state spaceA state space is the set of all possible combinations of values representing the states of a domain.
- value semanticsValue semantics are rules under which an entity is defined by stable descriptive values rather than by changeable state or identity.
- Order propertyAn ordering is a binary relation that arranges or compares elements according to specified properties such as reflexivity, transitivity, and antisymmetry.
- optionalityThe property of domain information that may be present or absent and whose absence has explicit meaning.
- sealed typeA sealed Java type restricts which classes or interfaces may directly extend or implement it.
- checklistA checklist is an ordered set of actionable items whose completion can be explicitly marked to control execution of a complex process.
- dependencyA dependency is a relationship in which one software element relies on another element's data, behavior, or availability.
- task instanceAn instance is a concrete occurrence of a template or checklist carried out during a particular activity.
- defensive programmingDefensive programming is a programming technique that anticipates invalid conditions and adds checks or safeguards to prevent their harmful effects.
- data addition operationA data addition operation combines two immutable data values into a new value representing their combined contents.
- group-by operationA group-by operation organizes input elements into keyed groups by repeatedly combining values associated with the same key.
- type signatureA declaration of the types associated with a callable's inputs and output or another typed program element.
- domain semanticsDomain semantics are the meanings and validity rules that a software model assigns to concepts in its problem domain.
- randomized test dataRandomized test data is test input whose values or cases are generated with deliberate variation rather than fixed in advance.
- evidenceEvidence is information that demonstrates that a required data condition or capability has been established.
- degreesA degree is an angular measurement unit equal to one three-sixtieth of a full rotation.
- unit of measurementA unit is a defined reference quantity used to express and compare measurements of a property.
- imperative shellAn architectural pattern that isolates deterministic computation in a functional core and places side effects and nondeterministic interactions in an imperative shell.
- object-oriented programmingObject-oriented design is a software design approach that organizes functionality around objects, their interfaces, and collaborations.
- elapsed daysElapsed days are the count of complete days that have passed since a relevant starting point.
- requirementsA requirement is a stated condition or capability that a software system or process must satisfy.
- concrete typeA data type whose representation and permitted values directly encode a particular meaning.
- equationAn equation is a statement that two expressions have the same value or meaning.
- mutable referenceA mutable reference is a reference that provides access to an object whose state can be changed.
- mockingA mock is a test-controlled replacement or implementation that stands in for an object or function and allows its behavior or interactions to be controlled.
- pipelineA pipeline is a sequence of processing stages in which data is passed from one stage to the next.
- attributeAn attribute is a named component of a data representation that describes one property of an entity or value.
- Curry-Howard correspondenceThe Curry-Howard correspondence is a relationship between formal logic and computation in which propositions correspond to types and proofs correspond to values or programs satisfying them.
- right-biased map operationA right-biased map operation resolves duplicate keys by selecting the value from the right-hand map.
- set operationA set operation is an operation that combines or compares collections according to set membership, such as intersection, union, or difference.
- unit testA unit test is an automated check that evaluates a relatively small, isolated unit of software behavior.
- impure functionAn impure function is a function whose behavior can depend on external state or produce observable side effects beyond its returned result.
- Cartesian productA Cartesian product is the set of all ordered tuples formed by choosing one element from each of several sets.
- classA Java declaration that defines a type by specifying its state representation and optionally its behavior.
- provenanceProvenance is information describing the origin and sequence of steps that produced a result or movement of data.
- code-first approachA code-first approach is a software development approach that begins by implementing a representation before fully investigating the domain meaning of the data.
- curingCuring is the chemical hardening process by which a drying oil becomes a protective film over time.
- data-oriented questionA data-oriented question is an inquiry that investigates what a piece of data means in its domain before choosing its representation.
- enumAn enum is a Java type construct that defines a fixed set of named constant values.
- defensive copyA defensive copy is an independently created duplicate of mutable data that prevents external mutation from changing the original representation.
- repository patternA repository is an abstraction that provides collection-like access to domain objects while hiding the underlying data storage mechanism.
- unmodifiable collectionAn unmodifiable list is a list whose exposed operations do not permit modification of its contents.
- nondeterminismNon-determinism is the property that identical inputs can produce different outputs because of hidden mutable state or other varying conditions.
- reliabilitySoftware reliability is the likelihood that software continues to perform required functions correctly under stated conditions.
- EqualsA book-specific rule model representing equality between an attribute and a value, with the value type parameterized by the attribute.
- operationAn operation is a rule that combines or transforms values from a specified set to produce a value.
- data transfer objectA data transfer object is a data-carrying structure used to exchange information between software components without encapsulating domain behavior.
- behaviorA behavior is a discrete computation or operation that changes a system from one state to another and produces outputs from inputs.
- monotonicityA monotonic function is a function that preserves the ordering of its inputs, mapping larger inputs to outputs that are not smaller.
- resource namingResource naming is the practice of assigning structured identifiers to external resources so they can be grouped, located, and removed systematically.
- test isolationIsolation is execution of a test without interaction with its external or substituted dependencies.
- insertAn insert is a database write description representing the creation of a new record.
- updateAn update is a database write description representing changes to an existing record.
- hardcodingHard coding is embedding environment-specific values or infrastructure assumptions directly in application code.
- shallow immutabilityShallow immutability is a condition in which an object's own fields cannot be changed while objects reachable through its references may still be mutable.
- constructor methodA constructor is a class member that initializes a newly created object and establishes its initial state.
- compact constructorA compact constructor is a Java record constructor form that omits the explicit parameter list and field assignments while allowing constructor-body validation and transformation of component values.
- hidden knowledgeHidden knowledge is information about required behaviors, assumptions, or validity conditions that exists in code but is not stated in requirements or exposed at an interaction boundary.
- shotgun parsingShotgun parsing is a parsing and validation style in which interpretation and checks are scattered across code paths, allowing assumptions and incomplete data to escape their intended boundaries.
- semantic couplingSemantic coupling is a dependency in which software structure reflects the meanings, representations, or contracts of external components.
- strategy patternThe Strategy pattern encapsulates interchangeable implementations of an operation behind a common interface.
- identity classAn identity object is an object whose distinctness is determined by its identity rather than solely by its current data values.
- expression-oriented shapeAn organization of method internals around expressions that evaluate to returned values rather than primarily around imperative assignments.
- expressive codeCode whose structure and data representations communicate its meaning directly and with little implicit behavior.
- algebraic reasoningAlgebraic thinking is the practice of reasoning about software operations through equations and properties that characterize their behavior.
- DegreesA book-specific data type representing angular degree values while enforcing the domain constraints of a contact angle.
- liftingLifting is a functional programming technique that adapts a function on ordinary values to operate within a wrapper or computational context.
- fluent interfaceFluent chaining is an API style in which successive operations are linked through return values to form an expression-like sequence.
- contextual attributeA contextual attribute is an attribute whose meaning applies specifically to a particular domain state or context rather than to the general concept.
- information leakageA design problem in which code outside a component must depend on knowledge of that component’s internal representation.
- mutable objectMutability is the property of a value or object whose state can change after it is created.
- couplingA dependency relationship in which one software component or test relies on the implementation details or behavior of another.
- side effectA side effect is an observable change or interaction caused by a computation beyond producing its returned result.
- data modelA database model is a structured representation of data entities, attributes, and relationships as persisted by a database.
- abstractionAn abstraction is a simplified representation that hides selected implementation details behind a more general concept or interface.
- code coverageCode coverage is a metric indicating which portions of source code are exercised by tests.
- water resistanceWater resistance is the ability of a wood surface or finish to resist the effects of water.
- invoiceAn invoice is a document or domain entity stating an amount owed for supplied goods or services.
- partitionA partition divides a set into subsets that are collectively exhaustive and pairwise disjoint.
- local reasoningA reasoning technique that determines a computation's behavior from its locally visible inputs, outputs, and dependencies.
- parameterizationParameterization is the technique of defining a type or computation in terms of explicit parameters that specialize its behavior or representation.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
