Atomic type
An atomic type is a type whose supported accesses and operations are indivisible with respect to concurrent execution and provide defined synchronization semantics.
Modern C, Third Edition
A type specifies the kind of values an entity can represent and the operations applicable to those values.
- How it is used
- Uses atomic types to communicate shared state between threads and support uninterruptible operations in signal handlers.
- How deep it goes
- Explains declaration constraints, indivisible operations, and modification order, while introducing type-generic atomic interfaces separately.
- Examples
- Uses a shared completion flag and cursor positions, a signal-handler counter, and two threads modifying an atomic variable.
- What you can do after
- Operate/configure atomic declarations for shared state and recognize when signal-handler operations require stronger guarantees than sig_atomic_t provides.
Modern C
A type is a C specification that determines the representation and permitted values or operations of an entity.
- How it is used
- Uses atomic types to coordinate shared state between threads and support uninterruptible operations in signal handlers.
- How deep it goes
- Explains atomic declarations, indivisibility, ordering, array restrictions, and consistency models, while deferring formal happens-before reasoning.
- Examples
- Uses atomic cursor positions and a completion flag, plus a lock-free signal counter and contrasting array declarations.
- What you can do after
- Apply _Atomic to shared objects and recognize when signal-handler operations require lock-free guarantees.
Get Programming: Learn to code with Python
An object type treated as indivisible because it cannot be separated into smaller object types.
- How it is used
- Distinguishes indivisible built-in values from object types assembled from other objects when organizing programs.
- How deep it goes
- Defines atomicity and classifies familiar Python types, then contrasts them with decomposable types without examining their implementation.
- Examples
- Uses a list of integers and a grocery-list scenario to contrast individual values with grouped objects.
- What you can do after
- Evaluate/understand whether a familiar Python type is atomic and when grouping values into another object type makes code clearer.
Read how Get Programming: Learn to code with Python explains atomic type →
API Design Patterns
A data type is a classification that specifies the kind of value a field can contain and how that value is represented.
- How it is used
- Frames API fields as language-agnostic representations chosen for client interoperability and clear meaning.
- How deep it goes
- Defines representation choices, contrasts primitives with richer inline types, and stops short of detailed serialization rules.
- Examples
- Uses image sizes, pixel dimensions, annotations, bounding boxes, notes, and resource identifiers as concrete representations.
- What you can do after
- Build API field definitions that preserve meaning across serialization and avoid unnecessary resource lifecycles.
C++ Concurrency in Action, Second Edition
An atomic type is a type whose operations provide atomic access to an object and support synchronization between threads.
- How it is used
- Provides low-level operations for synchronization between threads.
- How deep it goes
- Descends from atomic types into operations, memory ordering, and fences, including ordering between non-atomic operations.
- Examples
- Names standard types such as std::atomic<int> and contrasts lock-free operations with implementations using an internal lock.
- What you can do after
- Evaluate lock-free behavior with is_lock_free() and weigh atomic operations against a mutex-based implementation.
Read how C++ Concurrency in Action, Second Edition explains atomic type →
Kotlin in Action, 2E
A type is a classification that specifies the values an expression or variable can represent and the operations allowed on them.
- How it is used
- Classifies variables and expressions while guiding valid assignments, function calls, and operations.
- How deep it goes
- Defines values and operations, then develops inference, nullability, generics, classes, and subtype compatibility.
- Examples
- Uses String, Int, Double, List<Int>, nullable types, and assignments involving Int, Number, and String.
- What you can do after
- Evaluate/understand inferred types, nullable assignments, generic type forms, and subtype compatibility.
The Design of Web APIs, Second Edition
A data type is a classification that specifies the kind of value a data element can contain and how it may be represented or processed.
- How it is used
- Classifies API property values while resource models are shaped into inputs and outputs that meet consumer needs.
- How deep it goes
- Explains basic atomic types and practical format and extensibility trade-offs, without descending into implementation internals.
- Examples
- Uses an integer product reference, encoded end-of-cycle values, owner ID arrays, and string tags.
- What you can do after
- Apply it via JSON Schema to model property types, then evaluate formats and atomic values for consumer usability and future changes.
Read how The Design of Web APIs, Second Edition explains atomic type →
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
A data type defines the kind of value represented and the operations applicable to that value.
- How it is used
- Prevents scripting errors by enforcing expected values in variables, formatted output, and command parameters.
- How deep it goes
- Explains declarations, runtime inspection, conversion, testing, and enforcement, while stopping short of deeper type-system internals.
- Examples
- Demonstrates numeric input, Get-Member inspection, invalid conversion, -as and -is tests, and process-memory formatting.
- What you can do after
- Diagnose and prevent value-type errors with Get-Member, declarations, conversion, and type tests.
Code Like a Pro in Rust
A type is a compile-time classification that determines the values a program element can represent and the operations permitted on them.
- How it is used
- Uses static typing to constrain program inputs and outputs and focus unit tests on logic.
- How deep it goes
- Classifies Rust types and explains compiler-enforced constraints and their testing implications.
- Examples
- Uses strings and integers to illustrate type mismatches and fallible conversions.
- What you can do after
- Evaluate which checks the compiler provides and which conversion logic still needs testing.
Learn AI-Assisted Python Programming, Second Edition
- How it is used
- Uses types to select suitable data representations, function arguments, and tests.
- How deep it goes
- Defines common Python types and explains practical compatibility, but does not descend into type-system internals.
- Examples
- Demonstrates numeric function calls, sensor-reading collections, numeric strings, and varied function inputs.
- What you can do after
- Evaluate suitable inputs for Python functions and choose collection types for simple data.
Read how Learn AI-Assisted Python Programming, Second Edition explains atomic type →
PostgreSQL Mistakes and How to Avoid Them
A data type defines the kind of value a database can store and the operations permitted on that value.
- How it is used
- Prevents incorrect calculations and incompatible schema choices when selecting, converting, or migrating PostgreSQL data types.
- How deep it goes
- Explains integer division, implicit casting, type inspection, precision loss, and zero-denominator safeguards, but does not survey PostgreSQL's full type system.
- Examples
- Demonstrates order percentages, pg_typeof(), integer versus double division, and NULLIF or COALESCE for zero denominators.
- What you can do after
- Diagnose expression types, prevent truncated division, preserve precision during conversions, and guard database calculations against zero denominators.
Read how PostgreSQL Mistakes and How to Avoid Them explains atomic type →
Python How-To
- How it is used
- Frames ordinary Python data types through conversion and annotation examples, without deploying atomicity or concurrency.
- How deep it goes
- Stops at type inspection, conversion, dynamic reassignment, and hints; it does not descend into atomic operations or synchronization.
- Examples
- Uses age conversion and variable annotations, but supplies no example of concurrent atomic operations.
- What you can do after
- Evaluate ordinary Python type behavior through inspection, conversion, reassignment, and non-enforcing hints; concurrency behavior remains unspecified.
Python Workout, Second Edition
A type is a classification of Python objects that determines their values, behavior, and supported operations.
- How it is used
- Uses types to select compatible operations, preserve sequence behavior, and organize domain-specific objects.
- How deep it goes
- Works through strong typing, operator compatibility, sequence results, and the organizational distinction between classes and generic structures.
- Examples
- Uses numeric conversions, a polymorphic mysum exercise, sequence slicing, and a ScoreList average implementation.
- What you can do after
- Evaluate/understand which operations values support and when a domain concept merits a dedicated class.
Read how Python Workout, Second Edition explains atomic type →
100 Java Mistakes and How to Avoid Them
An atomic variable is a Java concurrency object that supports indivisible access and updates to a stored value.
- How it is used
- Diagnoses incorrect equality checks on atomic variables during concurrent-value comparisons.
- How deep it goes
- Explains payload access and timing consequences, but stops short of detailing atomic update internals.
- Examples
- Uses paired AtomicInteger instances to contrast equals() with get()-based value comparison.
- What you can do after
- Diagnose and correct atomic-value equality checks with explicit get() calls and update-timing checks.
Read how 100 Java Mistakes and How to Avoid Them explains atomic type →
Functional Design and Architecture: Examples in Haskell
A data type is a type that defines a set of possible values together with the constructors used to build those values.
- How it is used
- Models domain concepts explicitly and lets functions operate through meaningful, composable domain actions.
- How deep it goes
- Explains values, constructors, pattern matching, and compile-time rejection, while only surveying advanced type-level design.
- Examples
- Uses Shape with Circle and Rectangle constructors, an area function, and an invalid integer call that produces a type error.
- What you can do after
- Build domain representations and functions whose invalid inputs can be rejected by the compiler.
Read how Functional Design and Architecture: Examples in Haskell explains atomic type →
Also covered in
- 100 C++ Mistakes and How to Avoid Them
- Deep Learning with Python, Third Edition
- Grokking Simplicity
- Object-Oriented Software Design in C++
- Deep Learning with PyTorch, Second Edition
- Go by Example
- Software Design for Python Programmers
- Rust in Action: Systems programming concepts and techniques
- Go in Practice, Second Edition
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- React in Depth
- AI-Powered Search
What to know first
- integerAn integer is a whole-number mathematical value, including negative numbers, zero, and positive numbers, with no fractional part.
- stringA string is a programming-language value representing textual data as an ordered sequence of characters or encoded units.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- booleanA Boolean is a logical value or data type representing truth or falsity, conventionally with the two values true and false.
Related concepts
- classincludes · A class is a programming-language construct that defines a type’s structure and behavior and provides a basis for creating or representing objects.
- atomic_flagincludes · An atomic flag is a standard atomic type representing a flag and providing indivisible operations to set or clear it for synchronization.
- unit typeincludes · A unit type is a type with exactly one value, typically representing the absence of meaningful information and often written as ().
- integerused by · An integer is a whole-number mathematical value, including negative numbers, zero, and positive numbers, with no fractional part.
- primitive typeincludes · A primitive type is a predefined basic data type representing a simple value rather than a composite structure of multiple values or fields.
- enumincludes · An enum is a type whose values are selected from a finite set of named alternatives.
Questions about atomic type
What is atomic type?
An atomic type is a type whose supported accesses and operations are indivisible with respect to concurrent execution and provide defined synchronization semantics.
Which Manning books explain atomic type?
Modern C, Third Edition, Modern C, Get Programming: Learn to code with Python, Fast Python: High performance techniques for large datasets, API Design Patterns, C++ Concurrency in Action, Second Edition, Kotlin in Action, 2E, The Design of Web APIs, Second Edition and 9 more.
What should I know before learning atomic type?
Manning books that teach atomic type usually introduce integer, string, function and boolean first.
What kinds of atomic type are there?
Kinds of atomic type include class, atomic_flag, unit type, primitive type and enum.
What is atomic type also called?
Atomic type is also called atomic data types.
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.
















