Naming convention
A naming convention is an established set of rules or patterns for forming names consistently across software elements or other artifacts.
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.
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
- .NET MAUI in Action
- The Art of Unit Testing 3e
- Lead Developer Career Guide
- API Design Patterns
- The Coder CafeIn early access (MEAP)
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Designing AI SystemsIn early access (MEAP)
- "Looks Good to Me"
- Apache Kafka in Action
- Embedded Software with RustIn early access (MEAP)
- Grokking Software ArchitectureIn early access (MEAP)
What to know first
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- authorizationAuthorization is the determination of which actions or resources an identity or other entity is permitted to access under defined permissions or policies.
Related concepts
- snake caseincludes · Snake case is a naming convention in which words in an identifier are written in lowercase and separated by underscores.
- style guideconfigured by · A style guide is a documented set of conventions for writing and organizing source code consistently.
- resource namingproduces · Resource naming is the systematic assignment of clear, consistent, and identifying names to resources and their configurations.
- RESTcontrasts with · 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.
- stored procedureconfigures · A stored procedure is a named executable routine stored in a database and run by its database management system to perform operations.
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.









