Efficient Naming Conventions

𝐂𝐥𝐞𝐚𝐧 𝐧𝐚𝐦𝐢𝐧𝐠 𝐥𝐞𝐚𝐝𝐬 𝐭𝐨 𝐜𝐥𝐞𝐚𝐧 𝐜𝐨𝐝𝐞. If you want your .NET projects to be easier to read, maintain, and scale, consistent naming is one of the highest-impact habits you can build. Here is a refined set of guidelines you should follow: 𝟏. 𝐔𝐬𝐞 𝐏𝐚𝐬𝐜𝐚𝐥𝐂𝐚𝐬𝐞 𝐟𝐨𝐫 𝐏𝐮𝐛𝐥𝐢𝐜 𝐌𝐞𝐦𝐛𝐞𝐫𝐬 ↳ Use PascalCase for class names, methods, properties, enums, and public fields. ↳ Examples: CustomerService, GetCustomerDetails(), OrderStatus 𝟐. 𝐔𝐬𝐞 𝐜𝐚𝐦𝐞𝐥𝐂𝐚𝐬𝐞 𝐟𝐨𝐫 𝐋𝐨𝐜𝐚𝐥𝐬 𝐚𝐧𝐝 𝐏𝐚𝐫𝐚𝐦𝐞𝐭𝐞𝐫𝐬 ↳ Use camelCase for local variables, private fields (often with a leading underscore), and method parameters. ↳ Examples: customerName, orderAmount, _logger 𝟑. 𝐀𝐯𝐨𝐢𝐝 𝐀𝐛𝐛𝐫𝐞𝐯𝐢𝐚𝐭𝐢𝐨𝐧𝐬 𝐚𝐧𝐝 𝐔𝐧𝐜𝐥𝐞𝐚𝐫 𝐀𝐜𝐫𝐨𝐧𝐲𝐦𝐬 ↳ Names should clearly express intent. Skip short or cryptic terms. ↳ Examples: CustomerRepository (clear) CustRepo (unclear) 𝟒. 𝐏𝐫𝐞𝐟𝐢𝐱 𝐈𝐧𝐭𝐞𝐫𝐟𝐚𝐜𝐞𝐬 𝐰𝐢𝐭𝐡 "𝐈" ↳ Interfaces should start with the letter I to distinguish them from classes. ↳ Examples: IUserService, IDatabaseConnection 𝟓. 𝐔𝐬𝐞 𝐌𝐞𝐚𝐧𝐢𝐧𝐠𝐟𝐮𝐥, 𝐈𝐧𝐭𝐞𝐧𝐭𝐢𝐨𝐧-𝐑𝐞𝐯𝐞𝐚𝐥𝐢𝐧𝐠 𝐍𝐚𝐦𝐞𝐬 ↳ Choose names that instantly describe what the type or method does. ↳ Examples: OrderProcessor instead of ProcessOrder ValidatePayment instead of Check 𝟔. 𝐔𝐬𝐞 𝐒𝐢𝐧𝐠𝐮𝐥𝐚𝐫 𝐍𝐚𝐦𝐞𝐬 𝐟𝐨𝐫 𝐂𝐥𝐚𝐬𝐬𝐞𝐬 ↳ Use singular nouns unless the type represents a collection. ↳ Examples: Product (class) Products (collection) 𝟕. 𝐔𝐬𝐞 𝐕𝐞𝐫𝐛-𝐁𝐚𝐬𝐞𝐝 𝐍𝐚𝐦𝐞𝐬 𝐟𝐨𝐫 𝐌𝐞𝐭𝐡𝐨𝐝𝐬 ↳ Methods represent actions, so they should start with verbs. ↳ Examples: GenerateReport(), UpdateCustomer() 𝟖. 𝐅𝐨𝐥𝐥𝐨𝐰 𝐂𝐨𝐦𝐦𝐨𝐧 .𝐍𝐄𝐓 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 ↳ Stick to familiar .NET naming patterns for consistency. ⇢ Async methods end with Async: GetDataAsync() ⇢ Event handlers end with EventHandler: OrderCreatedEventHandler ⇢ Boolean names start with Is, Can, or Has: IsActive, HasExpired 𝟗. 𝐀𝐯𝐨𝐢𝐝 𝐇𝐮𝐧𝐠𝐚𝐫𝐢𝐚𝐧 𝐍𝐨𝐭𝐚𝐭𝐢𝐨𝐧 ↳ Do not include type information in variable names. ↳ Examples: string name ✔ strName ✖ 𝟏𝟎. 𝐊𝐞𝐞𝐩 𝐍𝐚𝐦𝐞𝐬 𝐂𝐨𝐧𝐜𝐢𝐬𝐞 𝐛𝐮𝐭 𝐃𝐞𝐬𝐜𝐫𝐢𝐩𝐭𝐢𝐯𝐞 ↳ Aim for clarity without unnecessary length. ↳ Examples: CalculateInvoiceTotal (good) CalculateTotalForInvoiceIncludingTaxesAndDiscounts (too long) Calc (too vague) P.S. Naming is one of the most powerful communication tools in software development. When names are intentional and consistent, your code becomes easier to read, easier to extend, and far more enjoyable for your team to work with. ♻️ Found this helpful? Share it. 🔔 Follow Elliot One for more Modern Engineering insights. #cleancode #designpatterns #dotnet #csharp #programmingtips #codingtips #technology

Your dbt project has a naming problem. You just don't know it yet. At 20 models everything feels fine. At 200, nobody knows what anything does or where it came from. dbt Labs published their conventions. Here's what actually matters: ➢ Prefix tells you the layer stg_ → staging (raw, source-conformed) base_ → base (used for unions or pre-staging) int_ → intermediate (business logic in progress) No prefix → marts (final, business-ready entities) ➢ Double underscore separates source from entity stg_stripe__payments, stg_shopify__orders The __ is intentional. Single underscore is part of the name. Double underscore is a delimiter. One glance and you know where the data comes from. ➢ Always plural orders, not order. payments, not payment. It's a table — it has many rows. ➢ Folders mirror your naming Staging models separated by the source, e.g /staging/stripe, /staging/shopify Marts and ints are separateed by the domain: /marts/finance, /marts/marketing ➢ One staging model per source table No exceptions. stg_stripe__payments is the single entry point for that table into your project. ➢ Marts use plain entity names customers, orders, payments — not finance_orders, not orders_per_day. Departmental prefixes create duplication. Time rollups belong in metrics, not model names. That covers the model layer. But column names matter just as much. ➢ Primary keys follow object_id account_id, order_id, customer_id — not just id. Always strings, not integers. It makes joins safer across systems. ➢ Booleans get is_ or has_ prefix is_active, has_subscription, is_deleted — never active, subscription, deleted. You always know it's a boolean without checking the schema. ➢ Timestamps end in _at, dates in _date created_at, updated_at, cancelled_at — all in UTC. If not UTC, be explicit: created_at_pt. Dates follow the same logic: created_date, due_date. ➢ Prices? Store as decimal. Add a suffix when you can't. 19.99, not 1999. If you must store cents, say so: price_in_cents. ➢ Column order is standardized across every model IDs → strings → numerics → booleans → dates → timestamps Those rules will put your project way ahead of many others. One set of rules. Zero guessing.

Ontology Design Patterns (Part 3): *Naming Things* Naming your predicates and classes (collectively terms) in the ontology is both an art and a science. The semantics associated with the term are the important thing, however the uncomfortable truth is that most developers or even data modelers will not read your carefully written scope notes, they'll just make assumptions based on the name and get back to coding. So, much like the (revised, thank you commenters!) principle of "Anticipate JSON-LD as the serialization", this is all about Developer Experience or Data Usability at the ontology level. If your names are easy to remember, consistent and easy to use in code, then your data has a step up before any instances are even created. Naming Rules I try to follow: * Most importantly, Be Consistent! Use the same naming conventions throughout the ontology. Every exception is a bug waiting to happen! * Names should be readable and in English. For better or worse, English is the language of computer science and, well, you have to pick a language for the name. Some ontologies instead use only numbers (such as RDA, wikidata, etc.) to avoid a linguistic bias, but this just makes it equally *unusable* for everyone. * Don't include numbers in the names at all, as it makes them impossible to remember. * Per basically all best practice guides, use camelCase for predicates and PascalCase for classes. * Do not use - in a name as then you can't use it in code (Human-MadeObject will be seen as Human - MadeObject) even though it's legal in URIs * Reserve _ as the first character of a term for internal use or extensions. This makes your internal fields clear to everyone, even if they're shared outside your organization. * As all terms must have unique names, if you find a situation where you want to use the same name as an existing term, then is it actually just the same term? For example, if you have 5 different "partOf" predicates for different classes, and you want to name them all "partOf" ... it's more likely that you just need an ancestor class in the hierarchy that defines the relationship for all of them. * Make a dictionary of the components used within the terms. e.g. do you use "id" or "identifier"? * Ensure the inverse relationship name directly reflects the relationship. If the relationship is (agent) "created" (object), then the inverse should be (object) "createdBy" (agent) not "author" or "maker". * Decide at the beginning of the project whether to include is/was/has/had (etc) at the beginning of term names. Is it "isPartOf" or just "partOf"? * Decide if abbreviations are all capitals or only the first character. Is it "hasXMLContent" or "hasXmlContent"? (Note that Linked Art doesn't follow all these rules as we inherited the ontology from the existing CIDOC-CRM specification. We did what we could to normalize them in the JSON-LD context, but this results in a pain point when you try to translate between JSON-LD and SPARQL queries.)

The importance of clear toolpath naming in CNC programming I see it all the time. A messy MasterCAM Toolpath Manager filled with Group1, Toolpath2, New Group like we are playing some kind of mystery game. Mastercam gives us the tools to keep things organized, but a lot of programmers just leave a trail of chaos for themselves and everyone else who touches their file. Naming your machine groups and toolpath groups properly is one of the easiest ways to improve efficiency in CNC programming, yet so many people skip this step. That might work for a quick one-off program, but if you ever need to revisit, modify, or hand off your work, that vague naming is going to cost you time and patience. Why it matters 1. Clarity. Your toolpaths should actually tell you something. No one wants to dig through Group1 or New Toolpath trying to guess what each operation does. 2. Efficiency. A well-organized toolpath list makes programming, troubleshooting, and edits way easier so you are not wasting time searching for operations. 3. Collaboration. If another programmer or machinist needs to step in, clear naming prevents misinterpretation and potential costly mistakes. Best practices for naming 1. Machine groups. Name them after the actual machine and setup. Example, HAAS VF2 SETUP1. 2. Toolpath groups. Indicate the operation type and key details. Example, OP10 FACEMILL or OP20 POCKET ROUGH. 3. Individual toolpaths. Keep names clear and consistent. Example, FINISH PASS 1/2 ENDMILL. 4. Use all caps. This improves readability and ensures consistency across files. 5. Avoid overusing acronyms and cutting out words. Sure, shorter names sound efficient, but when you come back to it later, you will be guessing what you meant. Instead of Finish pocket/doghouse walls, go with FINISH POCKET AND DOGHOUSE WALLS. A few extra keystrokes now can save a lot of frustration later. 6. Consistency. Standardize a naming structure so everyone in the shop knows what is what. 7. Avoid generic names. New Group or Toolpath1 helps no one. Be descriptive. A clean and structured Toolpath Manager is the sign of a professional CNC programmer. Do yourself and your team a favor and keep things clear and organized. What naming conventions do you use in your shop? Drop them in the comments. #CncProgramming #Mastercam #CNC #Manufacturing #Machining #Cnc加工 #PrecisionMachining #Toolpaths #CadCam #AerospaceManufacturing #MachineShop Jason Koger

Learn From My Mistakes: Naming Conventions in Marketo I’ve seen what happens when naming conventions go wrong. Confusion. Extra clicks. Wasted time. Duplicate work. And me asking myself, “Who named this like that?” So here’s what I’ve learned the hard way. What to DO ✅ Build a clear and consistent structure your whole team can follow ✅ Add essential details like campaign type, product or region, and date ✅ Stress-test your structure with real and hypothetical examples ✅ Document your naming rules and walk everyone through them What NOT to do (trust me) ❌ Using vague names like “Campaign 1” or “Q4 Promo” ❌ Skipping dates on time-sensitive programs ❌ Creating rules so complex no one can remember them ❌ Assuming everyone automatically understands the system A strong naming convention isn’t just neat. It keeps you organized, speeds up reporting, reduces errors, and makes collaboration smoother. Learn from my mistakes get your names right from the start.

Sure, it’s your dataset—you can name your variables whatever you want. But beware that poorly named variables can lead to confusion, even for you. Good naming ties into broader data standards—like the FAIR principles (Findable, Accessible, Interoperable, Reusable). 🔹 Findable: Names should be intuitive. 🔹 Accessible: Be searchable via a clear system. 🔹 Interoperable: Work across software and avoid special characters that software may misinterpret. 🔹 Reusable: Maintain a scalable naming convention for consistency. 🎯 How I Name My Variables Take current cigarette smoking, a binary variable (yes/no). I’d name it: ➡ currentcigt2o 🔹 current: The time period (current vs. ever). 🔹 cigt: The indicator (cigarettes; the "t" prevents confusion with cigars—specificity matters). 🔹 2: Number of categories (binary here; I use 0 for continuous, n for the nth number of categories). 🔹 o: My last character is either o (overall) or s (subset). In this case, this variable was assessed among all participants. This format tells me everything at a glance—time, topic, structure, scope—just like how a name like Chibuike might hint at eastern Nigeria. 🔟 Principles for Naming Variables 1️⃣ Clarity Over Freedom Just because you can name variables anything doesn’t mean you should. Prioritize names that are clear and meaningful, not cryptic or arbitrary. 2️⃣ Design for Sharing Name variables as if others will use them, even if you’re working alone. Future-you (or collaborators) will appreciate the clarity. 3️⃣ Follow FAIR Standards Make names Findable (intuitive), Accessible (searchable), Interoperable (software-friendly), and Reusable (scalable conventions). 4️⃣ Keep It Short but Informative Aim for brevity (e.g., under 15 characters) to avoid truncation, while embedding key details (e.g., time, type, scope). 5️⃣ Use Descriptive Roots Start with a root that signals the variable’s core (e.g., cigt for cigarettes) to avoid ambiguity. 6️⃣ Indicate Structure Add suffixes or codes for data type or categories (e.g., 2 for binary, 0 for continuous) to reveal the variable’s nature instantly. 7️⃣ Avoid Special Characters Stick to letters, numbers, and underscores (_). Avoid commas, periods, or symbols that certain software might misread. 8️⃣ Start with Letters, Not Numbers Begin with a letter (e.g., age25, not 25age) for interoperability—many systems reject numeric starts. 9️⃣ Standardize Case Use all lowercase to sidestep case-sensitivity issues across platforms. 🔟 Pair with a Codebook Document names and meanings in a codebook. It’s your data dictionary—essential for tracking, especially with missing values. 💡 Don’t know how to create a codebook? You’re in luck! Our webinar tomorrow on handling missing values will cover that as well—because you can’t talk about managing missing values without discussing codebooks. 📢 Sign up now—spots are limited! 🔗 Register here: https://chi2.io/HzlUQ6y Please reshare ♻️ #Chisquares #VillageSchool #DataScience

When creating custom fields in Salesforce, having a strong naming convention is important. Here is my convention, which you can copy. 1. Proper capitalization Always use title-style capitalization. This means most words are capitalized. Exceptions are words like "a", "an", "the", "but", etc. unless they they are the first word. E.g. "Do Not Automatically Create Payment", "Product Line Name" 2. Use front-loaded wording The first words are the most important, and allows users to understand them while scanning quickly. E.g. "Donation Type", not "Type of Donation". E.g. "Personal Benefits Description", not "Description of Personal Benefit" 3. Other When a picklist includes the value "Other", it should always be the last choice. Then add a text field with the same name as the picklist, appended with " Other". Add a validation rule to ensure a value is entered in the text field when the picklist value is "Other". E.g.: Picklist is "Availability", with values "A", "B", C", and "Other". Then the text field "Availability Other" is underneath. 4. Be wary of jargon and acronyms Not every user will be versed with internal wording and acronyms. Unless you are sure they will know, it's better to be more explicit. E.g.: "First Response Time" is clearer than "FRT". 5. Numbers and dates When creating a date or datetime field, append " Date". The word "Date" should not be the first word. E.g.: "Start Date", "First Contact Date". For number and currency fields, use " Number", " Amount", or just be descriptive. If it's a rollup, append " Count". E.g.: "External Number", "Receipt Amount", "Available Spaces", "Opportunity Count" What field naming conventions do you follow?

Inconsistent names? It leads to confusion, wasted time, and makes scaling design systems way harder than it needs to be. Ever struggled to find a component or had to rename a ton of elements? Yeah, we’ve all been there. 🚨 Messy naming kills efficiency, especially in team projects. Here’s a simple, structured approach to naming components effectively: ✔️ Component Type: (Button, Input, Card, etc.) ✔️ Content Type: (Icon+text, Text-only, Icon-only) ✔️ Size: (Small, Medium, Large, etc.) ✔️ Variant: (Primary, Secondary, Tertiary, etc.) ✔️ State: (Default, Hover, Pressed, Disabled, etc.) for example, Start broad, then drill down: 👉 Button → (What it is) 👉 Button / Icon Text → (What it contains) 👉 Button / Icon Text / Normal → (Size) 👉 Button / Icon Text / Normal / Primary → (Style) 👉 Button / Icon Text / Normal / Primary / Hover → (State) This way, your components are easy to find, reuse, and scale—no more guesswork! #ui #ux #uiux #componentui #figma #designsystem #uxtips #uitips #designtips

🚀 The Ultimate Cheatsheet for Naming Calculated Fields in Tableau One of the most underrated roadblocks in scalable dashboard development is naming inconsistency, especially when it comes to calculated fields. Whether you're in a small team or a large BI unit, chances are you've faced the chaos of poorly named fields: “Calculation1” “New_Calc” “abc123_test” ... sound familiar? This leads to confusion, longer onboarding time for new developers, and most critically, a lack of trust in your data product's structure. 👉 That’s why standardizing the way we name our calculated fields is not just good practice — it’s essential. 🔧 Here’s a naming convention framework I’ve found powerful and easy to adopt across teams: Category | Syntax | Example KPI Calculations | k.[KPIName].function | k.Sales.Variance Boolean Filters | b.[FilterName] | b.CurrentPeriod Map Calculations | map.[Chart].[function] | map.KPI.Label DZV | b.DZV[FilterName] | b.DZV.ShowTextTable String/Label Fields | l.[Field].[Function] | l.CustomerName.Wrap Parameters | p.[ParameterName] | p.ThresholdLimit 📌 Pro tip: Prefixing each type of calculation with a consistent short tag like k, b, or l not only improves readability but also makes them searchable in a crowded data model. 📥 Feel free to save this post or grab the visual reference below to keep this standard handy. Let’s build dashboards that are not only beautiful but built to last.