Attribute
An attribute is a named property, value, or piece of information associated with an entity, object, or program element.
Python Workout: 50 ten-minute exercises
An attribute is a named value or behavior associated with a Python object or class and accessed through attribute syntax.
- How it is used
- Organizes object data, behavior, module values, shared class settings, and relationships between composed objects.
- How deep it goes
- Explains instance, class, module, special, and method attributes, then works through ICPO lookup, inheritance, composition, and dataclasses.
- Examples
- Uses Scoop.flavor, Bowl.scoops, Bowl.max_scoops, os.sep, animal properties, and dataclass fields as concrete examples.
- What you can do after
- Build it from scratch by defining, reading, and reusing instance and class attributes across composed and inherited Python classes.
Read how Python Workout: 50 ten-minute exercises explains attribute →
Building User-Friendly DSLs
A named characteristic of a language concept whose type determines the kind of value or relation it can hold.
- How it is used
- Defines typed data characteristics that structure DSL content and connect record types with their values.
- How deep it goes
- Specifies names, types, optional initial values, relations, and structural migrations, but stops short of implementation details for defining attributes.
- Examples
- Uses car-rental record types and a Data Attribute migration that renames initial value to value.
- What you can do after
- Apply typed attributes to model DSL data and diagnose structural changes requiring AST migration.
Web Components in Action
- How it is used
- Uses HTML tag attributes to configure Web Component content, appearance, searches, and layouts.
- How deep it goes
- Works through reading, checking, observing, and reflecting attributes, including a re-entrancy pitfall.
- Examples
- Uses a photo carousel, configurable search component, and menu-selected business card layouts.
- What you can do after
- Build it from scratch: configure a custom element through markup and respond when selected attributes change.
Functional Programming in Scala, Second Edition
A property is a Boolean-valued statement about program behavior that should hold for a range of inputs or configurations.
- How it is used
- Specifies API behavior as invariants that generators test across many inputs.
- How deep it goes
- Defines properties, builds a Prop API, and distinguishes unfalsified results from exhaustive proofs.
- Examples
- Uses reverse, sum, max, sorted, takeWhile, and parallel-computation laws as testable claims.
- What you can do after
- Build properties from scratch with Gen, Prop.forAll, result reporting, and property combinators.
Read how Functional Programming in Scala, Second Edition explains attribute →
Kotlin in Action, 2E
An annotation is a declaration-associated metadata construct whose availability and retention can be configured for source processing, compiled class files, or runtime access.
- How it is used
- Adds metadata that tools, libraries, and reflection can use to customize declarations and JSON serialization.
- How deep it goes
- Explains application, arguments, use-site targets, custom declarations, and reflective handling; defers broader reflection API details.
- Examples
- Uses JUnit tests, deprecated functions, renamed property accessors, and JSON Person properties with exclusion, aliases, and custom serializers.
- What you can do after
- Apply annotations to mark APIs, target JVM-generated elements, and customize reflective JSON serialization.
Authorization in Action
An identity attribute is a piece of information describing an entity in a digital identity system.
- How it is used
- Supplies policy inputs for fine-grained, context-aware authorization decisions.
- How deep it goes
- Defines attribute categories and traces retrieval, freshness, schema design, and runtime policy evaluation.
- Examples
- Uses finance-report access, deployment scenarios, Google document relationships, and credential claims.
- What you can do after
- Evaluate/understand how current identity, resource, request, and environmental facts produce authorization decisions.
Python How-To
An attribute is a named value or behavior associated with a Python object and accessible through attribute access.
- How it is used
- Uses attributes to model application data and make related objects accessible through custom classes.
- How deep it goes
- Works through initialization, inspection, missing-attribute errors, properties, validation, and lazy access; does not develop attribute resolution order.
- Examples
- Shows a task’s instance dictionary and missing-status error, validated status assignments, cached profile data, and nested student account access.
- What you can do after
- Build it from scratch: initialize predictable instance attributes, inspect them, and introduce properties when access needs control.
Modern C, Third Edition
An attribute is supplemental implementation or semantic information attached to a C program construct.
- How it is used
- Adds information to C interfaces and implementations that can aid diagnostics, safety, security, or performance.
- How deep it goes
- Defines the bracket syntax and explains selected C23 attributes, including their effect on diagnostics and compiler assumptions.
- Examples
- Uses [[maybe_unused]], [[deprecated]] with a message, [[__unsequenced__]] on functions, and a conditionally annotated snprintf declaration.
- What you can do after
- Apply it via C23 attribute syntax and guard a compiler-specific annotation with __has_c_attribute.
Learn Rust in a Month of Lunches
A struct field is a named or positional component of a Rust struct whose visibility can be declared independently of the struct type.
- How it is used
- Uses fields to hold the named or positional values that make up a struct.
- How deep it goes
- Explains field declarations, initialization, access, and separate visibility, without descending into representation internals.
- Examples
- Shows a three-field `Country`, positional `ColorRgb` access, and a public struct with one private and one public field.
- What you can do after
- Operate/configure it by initializing struct fields and choosing which fields callers can access with `pub`.
Read how Learn Rust in a Month of Lunches explains attribute →
Python Workout, Second Edition
An attribute is a named value associated with a Python object and accessed through attribute lookup.
- How it is used
- Uses attributes to model object state and behavior while practicing classes, composition, inheritance, and built-in object patterns.
- How deep it goes
- Explains instance assignment through self, class-level declarations, dunder attributes, and __new__/__init__ sequencing; defers runtime type enforcement.
- Examples
- Practices Scoop, Beverage, LogFile, Book, Shelf, and dataclass examples with state, defaults, files, composition, and capacity checks.
- What you can do after
- Build instance and class attributes, then apply them in small Python classes and composed object models.
Read how Python Workout, Second Edition explains attribute →
The Quick Python Book, Fourth Edition
An attribute is a named value or behavior associated with an object and accessed through that object.
- How it is used
- Uses object attributes to store per-instance data, access class values, call methods, and expose computed values through dot notation.
- How deep it goes
- Explains creation and lookup of instance and class attributes, inherited access, and property getters and setters without descending into lookup internals.
- Examples
- Demonstrates a circle’s radius, class-variable shadowing, inherited instance variables, and a temperature property that converts units.
- What you can do after
- Build it from scratch with instance attributes and properties, while avoiding accidental class-variable shadowing.
Read how The Quick Python Book, Fourth Edition explains attribute →
Get Programming: Learn to code with Python
- How it is used
- Represents the data that defines an object and that its methods can use or change.
- How deep it goes
- Explains attribute selection, initialization with `self`, per-object values, and the difference between persistent attributes and temporary parameters.
- Examples
- Uses a circle’s radius, a rectangle’s length and width, and a stack’s list of items.
- What you can do after
- Build it from scratch by choosing attributes for a Python class and initializing them with `self` in `__init__`.
Read how Get Programming: Learn to code with Python explains attribute →
The Well-Grounded Rubyist, Fourth Edition
A property is an attribute or quality associated with an entity or object.
- How it is used
- Uses attributes to expose and maintain object state through reader and writer methods.
- How deep it goes
- Explains readers, writers, instance variables, shortcuts, mutability, and runtime inspection without exhaustive API detail.
- Examples
- Demonstrates ticket properties, Struct and Data records, and a Person object inspected before and after assigning an accessor.
- What you can do after
- Apply it via Ruby accessors to define, expose, mutate, and inspect object state.
Read how The Well-Grounded Rubyist, Fourth Edition explains attribute →
The Well-Grounded Python Developer: How the pros use Python and Flask
An attribute is a named value associated with a Python object or class and accessible through attribute lookup.
- How it is used
- Uses attributes to hold the state of individual Person instances.
- How deep it goes
- Explains instance attributes through self and a method that reads them, while deferring property-based access control.
- Examples
- Demonstrates fname, mname, and lname attributes in a Person class and uses them to form full names.
- What you can do after
- Apply plain attributes to store per-instance data and read it from a method.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains attribute →
Data Analysis with LLMs
A graph property is a named attribute associated with a graph node or relationship and holding a value.
- How it is used
- Uses properties to describe graph nodes and filter or project them in Cypher queries.
- How deep it goes
- Defines properties as key-value assignments and demonstrates matching and returning them, without descending into storage internals.
- Examples
- Demonstrates name and title properties in Movie and Person patterns, including a Tom Cruise lookup.
- What you can do after
- Operate/configure Neo4j queries that match graph elements by property values and return selected property values.
Practices of the Python Pro
An attribute is data associated with a Python object that represents part of its state.
- How it is used
- Organizes an object's changing data alongside the methods that operate on it.
- How deep it goes
- Explains state, initialization, and self-based access with a worked game example, stopping short of deeper attribute mechanics.
- Examples
- Uses a RockPaperScissorsSimulator with human_choice and computer_choice attributes.
- What you can do after
- Apply it via Python classes by initializing, reading, and updating instance data through self.
Build a Frontend Web Framework (From Scratch)
A named property of an HTML or DOM element that carries a value describing or configuring that element.
- How it is used
- Configures element nodes while mounting the virtual DOM by mapping supplied properties to DOM properties or attributes.
- How deep it goes
- Distinguishes reflected properties from input values and sketches separate class, style, and general-attribute helpers.
- Examples
- Uses a paragraph `id`, an input `value`, class strings or arrays, and individual style properties as examples.
- What you can do after
- Build attribute-setting helpers that handle class and style separately and remove attributes when values are null.
Read how Build a Frontend Web Framework (From Scratch) explains attribute →
Go in Practice, Second Edition
An annotation is metadata associated with program declarations or data structures to provide additional information for tools or runtime processing.
- How it is used
- Configures how encoders map struct fields into serialized data, with JSON field names as the concrete use.
- How deep it goes
- Demonstrates tag syntax, exported-field requirements, and JSON output, but not format-specific encoding internals.
- Examples
- Shows an Animal struct with tags that rename its fields in marshaled JSON.
- What you can do after
- Apply struct tags with encoding/json to choose JSON property names for exported struct fields.
Read how Go in Practice, Second Edition explains attribute →
Software Security for Developers
An attribute is a piece of information describing a user, resource, or environmental context that can be evaluated in an access-control rule.
- How it is used
- Uses user, resource, and environmental information to make dynamic authorization decisions through ABAC.
- How deep it goes
- Defines attributes, lists their forms, and demonstrates rule evaluation, but stops short of implementation details.
- Examples
- Uses department, clearance, region, ownership, sensitivity, time, IP address, and device type in access rules.
- What you can do after
- Evaluate/understand it by distinguishing attribute-based conditions from fixed roles and recognizing context-aware access rules.
Read how Software Security for Developers explains attribute →
100 Java Mistakes and How to Avoid Them
An annotation is structured metadata attached to program elements that tools or language processors can inspect.
- How it is used
- Uses annotations to communicate program intent to static analyzers and testing frameworks.
- How deep it goes
- Explains annotation-driven discovery through malformed test cases and analyzer limitations, but does not detail annotation declaration or processor internals.
- Examples
- Uses missing or wrongly imported @Test annotations, malformed test declarations, and IDE warnings as concrete examples.
- What you can do after
- Diagnose undiscovered tests and configure or extend static analysis without blindly applying suggested fixes.
Read how 100 Java Mistakes and How to Avoid Them explains attribute →
Rust in Action: Systems programming concepts and techniques
An attribute is Rust syntax that attaches metadata to a program item and can control compiler behavior such as conditional inclusion.
- How it is used
- Controls compiler warnings, enum representation, and platform-specific compilation in Rust code.
- How deep it goes
- Demonstrates warning suppression, conditional compilation, and fixed enum representations, including flexibility and optimization tradeoffs.
- Examples
- Uses unused-variable and dead-code warning allowances, platform-specific compilation, and a VGA palette enum represented by `u8`.
- What you can do after
- Configure warning handling, platform-specific code, and enum representation with Rust attributes.
Read how Rust in Action: Systems programming concepts and techniques explains attribute →
Pro Angular 16
An object property is a named value or function associated with a JavaScript object.
- How it is used
- Uses HTML attributes to configure browser behavior and apply Angular functionality to elements.
- How deep it goes
- Defines valued and valueless forms and demonstrates Angular expressions and literal quoting without detailing parsing internals.
- Examples
- Shows charset="utf-8", a required input, quoted Apples, and Angular Material button attributes.
- What you can do after
- Understand how HTML attributes configure elements and carry Angular expressions or literal values.
Julia as a Second Language
A field is a named component declared within a composite type and stored in each value of that type.
- How it is used
- Defines named, typed components for storing data in composite-type instances.
- How deep it goes
- Defines fields through typed struct examples and explains their fixed layout, without detailing compiler internals.
- Examples
- Uses Archer records with name, health, and arrows, plus a Vec2D type with coordinate fields.
- What you can do after
- Build from scratch a composite type with named, typed fields and read instance values through dot access.
Code Like a Pro in Rust
A struct field is an element of a struct value with a declared type and, in regular structs, a name.
- How it is used
- Use attributes to derive trait implementations, request C-compatible struct representation, or enable compiler warnings.
- How deep it goes
- Shows attribute effects with code examples, while deferring detailed treatment of derive and traits.
- Examples
- Uses a compound HashMap key, a C-mapped struct, and a missing-documentation warning.
- What you can do after
- Apply derive, repr(C), and lint attributes to implement traits, support FFI structs, and check documentation.
Data Pipelines with Apache Airflow, Second Edition
An attribute is a named property of a directory entry that stores a value describing the entity.
- How it is used
- Models information about directory entries as key-value data in a directory information tree.
- How deep it goes
- Defines attributes through entries, ObjectClasses, standard keys, and LDAP operations, without detailing attribute storage internals.
- Examples
- Uses person attributes such as sn and initials, plus LDAP compare, modify, and search operations.
- What you can do after
- Evaluate/understand how LDAP represents entities and locates, compares, or edits their attribute values.
Read how Data Pipelines with Apache Airflow, Second Edition explains attribute →
Secrets of the JavaScript Ninja, Second Edition
A named association on an object that holds a value or provides accessor behavior.
- How it is used
- Uses DOM attributes to read and update element values, and contrasts them with corresponding properties.
- How deep it goes
- Compares attribute and property behavior through id examples, but stops short of explaining when linked values differ.
- Examples
- Demonstrates changing a div’s id and tagging a function to prevent duplicate callback storage.
- What you can do after
- Operate DOM elements by reading or updating id through DOM methods or its corresponding property.
Read how Secrets of the JavaScript Ninja, Second Edition explains attribute →
Related concepts
- JSONpart of · JSON is a standardized, language-independent text format for representing structured data using objects, arrays, strings, numbers, Boolean values, and null.
- attribute-based access controlused by · Attribute-based access control is an authorization model that evaluates subject, resource, action, and contextual attributes against policies to make access decisions.
- primary keyused by · A primary key is a designated column or attribute, or combination of them, that uniquely identifies each row or item in a table or data store.
- tuplepart of · A tuple is a finite, ordered collection of elements treated as a single composite value or record.
- DynamoDB itempart of · A DynamoDB item is a record of attributes stored as a single entry in a DynamoDB table.
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.