Attribute
An attribute is a named property or piece of information associated with an entity, object, or structured data item.
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
- Uses attributes as decision-time inputs for context-aware authorization across principals, resources, requests, and environments.
- How deep it goes
- Explains attribute categories, dynamic policy evaluation, data sources, verification, and schema design through worked access scenarios.
- Examples
- Illustrates clearance-based access to a financial report and managed-device requirements for production deployment.
- What you can do after
- Apply attributes in authorization policies and evaluate their freshness, verification, and schema design.
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 connect cooperating custom classes.
- How deep it goes
- Works through initialization, inspection, properties, setters, and lazy loading; contrasts properties with __getattr__ without detailing attribute resolution order.
- Examples
- Uses task status and tags, student account data, lazy user profiles, and a partial-function inspection challenge.
- What you can do after
- Apply attribute initialization, inspection, and property-based access control when designing Python classes.
Modern C, Third Edition
An attribute is supplemental implementation or semantic information attached to a C program construct.
- How it is used
- Uses attributes to annotate interfaces and implementations with supplemental information for compilers and tools.
- How deep it goes
- Defines attribute syntax and selected meanings, including function interference and diagnostic behavior, and illustrates conditional use of an implementation-specific attribute.
- Examples
- Illustrates deprecated and unsequenced annotations and a conditional GNU format attribute on snprintf.
- What you can do after
- Evaluate attributes as annotations that can convey function properties or suggest diagnostics.
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 assemble values into struct types and control access to their components.
- How deep it goes
- Explains named and positional fields, initialization shorthand, access, and independent field visibility.
- Examples
- Uses Country initialization, ColorRgb positional access, and a public struct with one private field.
- What you can do after
- Build it from scratch by declaring and initializing structs with named or positional fields, and choosing which fields are public.
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 attributes to hold instance data and expose methods through Python objects.
- How deep it goes
- Explains creation, lookup, inheritance, shadowing, and properties with worked examples, without developing object-oriented programming as a whole.
- Examples
- Demonstrates circle radius and pi fields, inherited variables, and a temperature property; exercises include rectangle dimensions.
- What you can do after
- Operate/configure attributes by creating instance fields, changing class variables, and defining property getters and setters.
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 →
Web Component Development with Modern Libraries and Tooling
A named value associated with a JavaScript object or component instance, which may represent component state or be exposed through accessors.
- How it is used
- Supplies web-component data through HTML markup while supporting updates through the DOM.
- How deep it goes
- Explains string-valued attributes, observed changes, property synchronization, and rich-data limits through component implementations.
- Examples
- Shows a greeting updated by changing its name attribute and a sortable table configured with headings and properties attributes.
- What you can do after
- Build it from scratch: expose primitive component data through synchronized attributes and properties while reserving properties for objects and arrays.
Read how Web Component Development with Modern Libraries and Tooling explains attribute →
Vanilla Web
A JavaScript property is a named value associated with an object.
- How it is used
- Configures native elements and gives custom elements a simple, declarative interface for behavior or data.
- How deep it goes
- Distinguishes markup attributes from JavaScript properties, including string values, reflection, form-state divergence, and DOM access methods.
- Examples
- Uses an input whose attribute and property diverge, plus a star-rating element configured with a value attribute.
- What you can do after
- Build it from scratch: choose and document custom-element attributes, read them through DOM APIs, and avoid assuming property synchronization.
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 →
The Design of Web APIs, Second Edition
A property is a named data element belonging to a JSON object that describes one of its values or characteristics.
- How it is used
- Uses properties to represent resource data that consumers need, including identifiers and selected data from related resources.
- How deep it goes
- Works through selection, names, types, and nested schemas; defers marking properties required in the nested-object schema example.
- Examples
- Uses product fields, a nested supplier schema, a transfer’s cancellable flag, and a 201-response id-rule exercise.
- What you can do after
- Build it from scratch by selecting consumer-relevant properties, then describing their names, types, and nested structure in JSON Schema.
Read how The Design of Web APIs, Second Edition explains attribute →
F# in Action: A Revised Edition of Get Programming with F#
An attribute is metadata attached to a program element to provide declarative information consumed by the compiler or runtime.
- How it is used
- Marks F# test functions and shared setup for discovery by an NUnit-style test runner.
- How deep it goes
- Shows attribute placement and its effect on test discovery, without explaining compiler or runtime internals.
- Examples
- Shows two `[<Fact>]` functions that test instrument sounds with `Assert.Equal`.
- What you can do after
- Apply it via XUnit to mark F# tests for discovery and run them with `dotnet test`.
Read how F# in Action: A Revised Edition of Get Programming with F# 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 →
Data-Oriented Programming in Java
An attribute is a named component of a data representation that describes one property of an entity or value.
- How it is used
- Uses attributes to shape data representations, test domain meanings, and encode valid business-rule inputs.
- How deep it goes
- Explains attribute combinations as implicit ANDs and refactors conflicting combinations, but stops short of general attribute semantics.
- Examples
- Uses Status, Completed, Equals rules, invalid attribute-name strings, and an Attribute enum as concrete modeling examples.
- What you can do after
- Evaluate data models for conflicting attribute combinations and constrain rule inputs with an enum.
Read how Data-Oriented Programming in Java 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 →
The Coder Cafe
A software property is a general behavioral statement that a program or system is expected to satisfy across applicable inputs or executions.
- How it is used
- Guides property-based testing toward behavioral rules that remain valid across randomized inputs instead of isolated manually selected cases.
- How deep it goes
- Defines attributes through examples and applies them from local functions to system-level invariants, without implementation-level detail.
- Examples
- Uses structural preservation, idempotency, commutativity, crash resistance, latency, consistency, and balanced financial transactions.
- What you can do after
- Apply it via property-based testing to express and check correctness beyond predefined test scenarios.
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 →
Also covered in
- Grokking Relational Database Design
- Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
- Essential TypeScript 5, Third Edition
- Graph Algorithms for Data Science
- Statistics Every Programmer Needs
- Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
- Practical Automation with PowerShell: Effective scripting from the console to the cloud
- API Design Patterns
- Modern C
- Software Design for Python Programmers
- Data-Oriented Programming: Reduce software complexity
- JavaScript in DepthIn early access (MEAP)
What to know first
- 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.
- objectAn object is a distinct entity represented or manipulated within a computational system, typically as a value, data structure, resource, or instance of a type.
- classA class is a programming-language construct that defines a type’s structure and behavior and provides a basis for creating or representing objects.
- HTMLHTML is the standard markup language for structuring content and elements in documents on the web.
Related concepts
- 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.
- JSONpart of · JSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- accessor descriptorincludes · An accessor descriptor defines an object property whose value is read or changed through getter and setter functions rather than directly stored.
- derivation formulaused by · A derivation formula is a rule applied to matched events to determine a derived event.
- DynamoDB itempart of · A DynamoDB item is a record of attributes stored as a single entry in a DynamoDB table.
Questions about attribute
What is attribute?
An attribute is a named property or piece of information associated with an entity, object, or structured data item.
Which Manning books explain attribute?
Python Workout: 50 ten-minute exercises, Building User-Friendly DSLs, Web Components in Action, Functional Programming in Scala, Second Edition, Kotlin in Action, 2E, Authorization in Action, Python How-To, Modern C, Third Edition and 24 more.
What should I know before learning attribute?
Manning books that teach attribute usually introduce function, object, class and HTML first.
What kinds of attribute are there?
Kinds of attribute include accessor descriptor and common attribute.
What is attribute part of?
Attribute is part of JSON. JSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
What is attribute also called?
Attribute is also called property, field or trait.
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.































