liveBook · Manning

Attribute

Also called property, field, trait

An attribute is a named property or piece of information associated with an entity, object, or structured data item.

How 32 Manning books explain it

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.

Read how Building User-Friendly DSLs explains attribute →

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.

Read how Web Components in Action explains attribute →

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.

Read how Kotlin in Action, 2E explains attribute →

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.

Read how Authorization in Action explains attribute →

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.

Read how Python How-To explains attribute →

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.

Read how Modern C, Third Edition explains 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 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.

Read how Vanilla Web 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 →

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.

Read how Data Analysis with LLMs explains attribute →

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.

Read how Practices of the Python Pro explains attribute →

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.

Read how Pro Angular 16 explains attribute →

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.

Read how Julia as a Second Language explains attribute →

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.

Read how Code Like a Pro in Rust explains attribute →

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.

Read how The Coder Cafe 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 →

Also covered in

What to know first

Related concepts

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.