liveBook · Manning

Naming convention

Also called naming scheme, naming standards

A naming convention is an established set of rules or patterns for forming names consistently across software elements or other artifacts.

How 10 Manning books explain it

Software Engineering for Data Scientists

A naming convention is a prescribed pattern for naming program elements such as variables, functions, and constants.

How it is used
Standardizes Python names so shared data-processing code remains readable and PyTest can discover tests.
How deep it goes
Demonstrates constant, function, parameter, and test-prefix naming through before-and-after Python snippets.
Examples
Uses customer-churn processing, `NUM_STATES`, `process_data`, `num_samples`, `total`, and `test_` functions.
What you can do after
Apply it via Python and PyTest by naming code elements clearly and marking discoverable tests with `test_`.

Read how Software Engineering for Data Scientists explains naming convention →

100 SQL Server Mistakes and How to Avoid Them

A naming convention is a prescribed pattern for naming software elements such as schemas, tables, columns, or code symbols.

How it is used
Makes database objects and SQL Server instances identifiable during development, maintenance, and troubleshooting.
How deep it goes
Explains naming through debugging and deployment scenarios, but defers a universal instance-name formula to organizational context.
Examples
Uses ambiguous stock-update procedures, procedure-listing SQL, and application-named SQL Server instances across two servers.
What you can do after
Apply it by choosing meaningful names that speed object discovery and remain understandable through operational change.

Read how 100 SQL Server Mistakes and How to Avoid Them explains naming convention →

Modern C

A naming convention is an established pattern for representing words or semantic information in identifiers.

How it is used
Guides identifier choices so C code remains readable, consistent, and resistant to namespace collisions.
How deep it goes
Explains technical restrictions, reserved forms, namespace exposure, and distinguishability, but does not specify one universal semantic style.
Examples
Uses a colliding array declaration, a prefixed revision, and pairs such as myLineNumber versus myLimeNumber.
What you can do after
Apply it via a consistent naming policy that limits global exposure and makes identifiers conforming and distinguishable.

Read how Modern C explains naming convention →

Unit Testing Principles, Practices, and Patterns

A test naming policy is a set of rules governing how tests are named to communicate their scenarios and intent.

How it is used
Communicates test scenarios and expected behavior while reducing the maintenance cost of deciphering cryptic names.
How deep it goes
Contrasts rigid templates with plain-English names and demonstrates refactoring, but does not examine naming automation or tooling.
Examples
Uses calculator addition and delivery validation tests to contrast rigid names with plain-English behavioral names.
What you can do after
Apply it by renaming tests around observable scenarios, domain language, and expected behavior rather than method signatures.

Read how Unit Testing Principles, Practices, and Patterns explains naming convention →

Authorization in Action

A naming convention is an agreed pattern for assigning identifiers so related entities or policy elements are named consistently.

How it is used
Uses consistent identifiers and policy names to support identity discovery, authorization, governance, and maintainable policy reviews.
How deep it goes
Explains naming tradeoffs through incidents and examples, then connects conventions to schemas and reviews without detailing identifier implementation.
Examples
Uses the TSA No-Fly List incident, ACME identifier choices, inconsistent action names, and Cedar’s doc:view action.
What you can do after
Apply it via policy schemas, reviews, and tests to keep identifiers and authorization actions consistent.

Read how Authorization in Action explains naming convention →

The Design of Web APIs, Second Edition

A naming convention is a prescribed way of forming and applying names consistently within an API or across APIs.

How it is used
Aligns API names and data structures so developers can recognize resources and work with interoperable data.
How deep it goes
Works through identifier trade-offs and consistency across data names, types, and structures, without specifying a complete naming taxonomy.
Examples
Compares accountId, iban, and id, and contrasts consistent data patterns for accounts and money transfers.
What you can do after
Apply consistent names and data patterns to resource identifiers and API models.

Read how The Design of Web APIs, Second Edition explains naming convention →

Java Persistence with Spring Data and Hibernate epub

A naming convention is a prescribed pattern for naming database objects or other artifacts consistently.

How it is used
Enforces consistent database and query names across Hibernate, JPA, and Spring Data persistence mappings.
How deep it goes
Explains explicit names, quoted identifiers, custom physical strategies, configuration, and JPQL entity-name collisions.
Examples
Uses @Table(name = "USERS"), a CE_ table prefix strategy, persistence.xml properties, and explicit AuctionItem entity naming.
What you can do after
Apply it via Hibernate configuration or explicit JPA annotations to enforce physical names and disambiguate query entities.

Read how Java Persistence with Spring Data and Hibernate epub explains naming convention →

Grokking Relational Database Design

A naming convention is a consistent set of rules for naming database objects and their components.

How it is used
Improves database usability and maintainability for administrators, analysts, developers, and other database users.
How deep it goes
Defines table and attribute naming choices, compares common styles, and checks column-length limits.
Examples
Uses id, Id, identifier, employee, employees, first_name, and other casing styles as naming examples.
What you can do after
Apply it by selecting consistent table and attribute conventions and checking names against database length limits.

Read how Grokking Relational Database Design explains naming convention →

Modern C, Third Edition

A naming convention is a systematic rule for choosing identifiers so that related entities are recognizable and less likely to collide.

How it is used
Reduces identifier collisions and improves accessibility when writing macros, variables, functions, and types.
How deep it goes
Defines documented naming as a safety practice, demonstrates swap-prefixed locals, and stops short of guaranteeing collision-free macro expansion.
Examples
Uses swap_p1, swap_p2, and swap_tmp as protected macro-local names and r, g, and b as type-generic member names.
What you can do after
Apply it by documenting distinctive local-variable names inside macros and evaluating remaining collision risks.

Read how Modern C, Third Edition explains naming convention →

Spring in Action, Sixth Edition

A naming convention is a prescribed pattern for names that allows software to infer structure or behavior from those names.

How it is used
Drives Spring Data repository behavior by encoding data retrieval conditions and sorting rules in Java method names.
How deep it goes
Explains recognized operators, case handling, sorting, and explicit queries, but defers complex queries to @Query.
Examples
Shows delivery-zip lookup, date-range filtering, case-insensitive matching, delivery-name sorting, and Seattle orders.
What you can do after
Apply it via Spring Data by defining repository methods for simple queries and using @Query for complex ones.

Read how Spring in Action, Sixth Edition explains naming convention →

Also covered in

What to know first

Related concepts

Questions about naming convention

What is naming convention?

A naming convention is an established set of rules or patterns for forming names consistently across software elements or other artifacts.

Which Manning books explain naming convention?

Software Engineering for Data Scientists, 100 SQL Server Mistakes and How to Avoid Them, Modern C, Unit Testing Principles, Practices, and Patterns, Authorization in Action, The Design of Web APIs, Second Edition, Java Persistence with Spring Data and Hibernate epub, Grokking Relational Database Design and 2 more.

What should I know before learning naming convention?

Manning books that teach naming convention usually introduce SQL, software testing, contract and authorization first.

What is the difference between naming convention and REST?

A naming convention is an established set of rules or patterns for forming names consistently across software elements or other artifacts. REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.

What kinds of naming convention are there?

Kinds of naming convention include snake case and singular naming convention.

What is naming convention also called?

Naming convention is also called naming scheme or naming standards.

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.