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 through small shared objects without conflicting non-atomic accesses between threads.
- How deep it goes
- Explains atomic declarations, indivisible operations, modification order, and lock-free limits for signal handlers.
- Examples
- Shows shared completion and cursor fields, valid and invalid array declarations, a signal-handler counter, and two threads updating one atomic.
- What you can do after
- Apply it via `_Atomic` to declare small shared objects and distinguish atomic access from mutex-protected critical sections.
Modern C
A type is a C specification that determines the representation and permitted values or operations of an entity.
- How it is used
- Protects small shared data and supports synchronization between threads; also supplies uninterruptible operations needed in signal handlers.
- How deep it goes
- Explains declaration forms, indivisibility, linearizability, array restrictions, signal-handler limits, and consistency choices without developing an atomic algorithm here.
- Examples
- Uses a shared completion flag and cursor members, contrasting valid atomic array elements with an invalid atomic array.
- What you can do after
- Apply `_Atomic` to suitable shared members and distinguish atomic access from cases requiring a mutex or stronger signal-handler 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 →
Fast Python: High performance techniques for large datasets
- How it is used
- Uses numeric dtypes to manage overflow and data-frame memory, without deploying atomic types for concurrent access.
- How deep it goes
- Works through width conversion and precision checks, but does not define atomic operations or synchronization.
- Examples
- Tests uint8 grayscale overflow and float32 taxi-fare error; neither example tests concurrent access.
Read how Fast Python: High performance techniques for large datasets 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
- Uses atomic types to model API data and make values understandable and interoperable for consumers.
- How deep it goes
- Explains type selection, requiredness, and readability, while deferring performance, security, and implementation constraints.
- Examples
- Uses washing-machine time values, Product properties, JSON Schema, and YAML or JSON atomic values as examples.
- What you can do after
- Apply it via JSON Schema and OpenAPI to select and describe consumer-oriented API property types.
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 types to model Rust data and separate compiler-checked constraints from behavior that needs tests.
- How deep it goes
- Defines four type categories and explains their testing implications, without providing an exhaustive language reference.
- Examples
- Contrasts strings with integers and uses an atomic integer in a shared test counter.
- What you can do after
- Evaluate/understand which guarantees Rust’s compiler supplies and which behaviors still warrant tests.
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 →
Related concepts
- classincludes · A class is a programming-language construct that defines a type’s structure or 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, commonly written (), that represents the absence of meaningful information or a meaningful result.
- integerused by · An integer is a whole-number value with no fractional part, including negative numbers, zero, and positive numbers.
- primitive data typeincludes · A primitive data type is a fundamental, language-provided type for representing a basic value, rather than a composite of multiple values.
- race conditionaddresses · A race condition is a concurrency defect in which program behavior or results depend on the relative timing or ordering of interacting operations.
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.