Whats your go-to naming convention?

It depends a bit on the use case. I try to follow naming conventions within specific environments like Python. When just sorting some documents together, I usually do a mix of Kebab and snake case, where I split semantic parts with underscores and connect words with dashes like

2024-08-30_author_document-name_other-important-info.ext

Snake case.

• Starts with a lowercase, good for shell autocompletion
• No spaces, so no worrying about spaces in shell commands
• '_' is better than '-' because it shows the spaces between words more clearly

I put an unnecessary amount of spaces in all my file names to break anyone who wants to use CLI tools on them

i use windows btw

COOLFI~1.AME

Underscore to delineate different parts, hypen to delineate words.

Like: my-resume_draft.pdf

And to make it consistent and easier to reuse parts for project names and such, I have a command line utility written for it. It caches the parts and uses a template system (support for generating current datetime in parts)

Available here (is in AUR too):

https://github.com/Atreyagaurav/nameit

I like Camel Case for code, but mostly because it's ingrained in my brain, coming from Java as my first language.

For folders and files, I like Kebab Case.

SCREAMING_SNAKE_CASE just has the best name

I am a fan of Python's or Rust's official conventions.

For package names, tho, I don't get why this-is-used over this_clearly_better_system, as I would expect a double click to select_the_whole_thing, whereas it does-not-happen-here.

How about "cool file name"?

All my systems use modern file systems that are case sensitive and can contain any character except / and \0.

Camel case, but with a twist -- if the next word is about to start after a capital letter, I'll have it lower case.

topSecretFBIfile.txt for example

IT'S

COOLFILE.NAM

THERE IS ONLY 8.3 AND THERE IS ONLY UPPERCASE

For files, kebab case. For variables, snake case. For servers, megaman villains.

I like to use my enterprise number and a UUID (all in lower case, for legibility). Here's an example:

.1.3.6.1.4.1.33230.0d456e46-67e6-11ef-9c92-7b175b3ab1f1

Now you might say that the UUID is already globally unique or at least pretty unlikely to turn up anywhere else, so why bother prefixing it with more stuff? To that I say: "I need to be absolutely or at least reasonably sure ... OK nearly sure".

Anyway, you maintain a database of these things and then attach documentation and meaning to them. An editor could abstract and hide that away.

I started this post as a joke. Not sure anymore. Why get your knickers in a twist with naming conventions for variables and constants. Programming is already a whopping layer of abstraction from what the logic gates are up to, another one wont hurt!

Snake case. I find it the easiest to read.

The only correct answer is to be consistent with the code base you're working in or the language's conventions. If neither of these conventions exist, then someone has already failed you.

For files? An unholy amalgam of snake, kebab and dot, depending on what exactly I'm trying to convey. (I still have much-ported files around with DOS 8.3 filenames, so they're truncated scream case (SCREAMIN.NAM), but I don't actively name files like that anymore.) The important thing is to separate the words/sections while using characters that are valid without escapes in both ext4 and vfat if at all possible.

For variable names, camel or Pascal case (depending on language convention) if I think anyone else is going to read it. Flat case for code I don't think anyone else is ever going to see (don't do this—it has left teethmarks in my ass from time to time and will do the same to you).

Random mix and match. I’m all for diversity!

I’ve never been to a naming convention but I have been to some comic conventions!

Unless I can't, Kebab.

No need to hold Shift.

Kebab. Not my favorite visually speaking but I had RSI issues for a while and I'm still very focused on limiting keystrokes (no shift key needed with kebab).

WIAT, Y R U CALLIN IT SCREAMING CASE THAT SOUNDS FKN DUM TBH

L8R DOODZ

-SP4SEM4N B1FF

Snake case, but I'm the World's second worst programmer and just name files like this because I was alive when spaces were not allowed.

It really depends.

If I know I will never open the file in the terminal or batch process it in someways, I will name it using Common Case: "Cool Filename.odt".

Anything besides that, snake case. Preferably prefixed with current date: "20240901_cool_filename"

Kebab or snake for ease of parsing through them.

Rfc3339 plus kebab case for many things

2024-09-01_lname-fname-resume.pdf

I've got a personal convention that file names get snake case, directory names get Pascal case.

Depending on environment/language and policies. As long as its consistent throughout the project.

I like snake, but in some interfaces the underscores blend into the text line or are not rendered properly, so it becomes eaaier to discern if the filename has spaces or separators by using kebab.

Depends. Java-like languages ofc camel/pascal case.
Bash, Python, etc., snake case, with constants as uppercase.
Filenames: I prefer snake case.

This question just shows how messed up, and broken much of IT is.

It heavily depends on the context: Filenames? Variables? Functions? Interfaces/Classes? Java? C? Shell?

IWRITELOTSOFBASH

Snake case, usually. Some perhaps unfounded fear that something will blow up on a dash in a file name kicking around. Or I'll do a weird typo/premature enter and part of the file name will be treated like a -flag of some sort.

Whatever case I get when my finger reaches the shift key.

Pascal_Snek_Case

I don't like it but I am used to reading old C codebase (windows: https://learn.microsoft.com/en-us/windows/win32/stg/coding-style-conventions) with Hungarian notation.

pszMyString 😥

I generally end up using snake case.

My file

I've got one more to add to your list, and I hate it, but it's worth mentioning: https://en.m.wikipedia.org/wiki/Hungarian_notation

It's when the data type is in the name of the variable.

General purpose: Kebab case

But really, follow the conventions of what you're working on. For example, I'd use pascal case when working on a Java/Kotlin project, and snake case when working on a Python project.

I kebab case mine for personal files.

It's mostly because I don't have to use a modifier key and it's doesn't need url encoding and all in the same lowercase. Dot notation looks nice but I feel like dots are for extensions only. Flat case is horrible to read, screaming case even worse, camel/pascal case to many times ends up as coolFileNAme on first time typing.

I've done a couple of different styles because of programming in different languages but now if I have to do anything that's not kebab case I make a small frown.

code: camel or snake, depending on language

files/dirs: snake + kebab + dot mixture (trying to avoid caps and special chars here)

Camel case for short names snake case if it starts getting hard to read

1337 case = k3wlf1l3n4m3

CaN't BeLiVe No OnE eLsE uSeS mOrOn ScRiPt FoR eVeRyThInG!

Have been defaulting to kebab case for variable and function names in all languages recently because of cargo yelling at me

Pascal case for class names cause c#, snake case for python files because it doesn't like kebab

Screaming case for env files because that's what everybody else does

I don't have a consistent style for everything and it depends on the circumstances. snake_case is often used, especially to avoid spaces. Sometimes I just do flatcase instead, and in rare cases also kebab-case or combined_snake-and-kebab-case. The combined_case is often useful to group parts of the name, like a dates and version numbers together and to indicate what part is constant; example-name_2024-08. Sometimes I also do the "Title Case", which is basically PascalCase, but with spaces. Or even even more weird, "Python_Case", which is PascalCase, but with snake_case, when I want to avoid spaces.

I often avoid dots in regular filenames, unless they indicate a file extension or format, such as ".svg" and ".inkscape.svg" to indicate its a specific version of the SVG format. Or ".xiso.iso", as a specific compressed version of the regular ISO file (for use with Xemu emulator). Basically the same logic and tradition as ".tar.gz" (but in reverse order).

FileName_IMPORTANTCATEGORIZATION.yyyy.ext

With all bits being optional (not every file needs the date it refers to)

So eg (slight modifications for anonymity): SunLifeInsureance_SIGNED.2024.Q1.pdf

SpotDoesTrickAndFalls_ORIG.mp4

JSmithPassport_CANADA.2015_2025.pdf (I am a dual citizen)

JSmithCOVIDPass_DOSE1.2021.pdf

Snake case for all kinds of file names and camel case for programming

For files? I like title case (like in article headlines). For example, I have a "Shell Tricks.txt". I'm not really consistent though, sometimes it's all lowercase or whatever really.

Snake case and kebab case mixed arbitrarily.

I try to make everything Pascal case. It's easy to read in a terminal and pretty easy to type.

I use flat case most of the time, but I also try to stick to single word files so there is no case to get in the way.

I think for documents I might share like a PDF I'd use Pascal case.

In a classroom or teaching setting I will sometimes use Kebab case as I find it is the least confusing and makes it extra clear where the word division is. Similarly I avoid Dot notation since it's confusing for folks coming from a Windows world.

And I would avoid Screaming because that's just too loud anywhere.

stOcHaStIC-l33t-CasE FTW yizzo.

Snake if writing in python

Camel if writing in PowerShell

I tend to stick with what the language wants me to use.

Depending on the file it’s either dot notation or flat case.

PascalCaseForTheWin

Me, a sick fuck, who likes a quick fuck:

/etc/moron-syntax/I\ write\ like\ a\ gay\ fish\ \(\Kanye\)\

Kebab for most things, camel for source code

Snake case or kebab case I guess. But why is it called kebab case?

Pascal or camel case for code, snake case for files and screaming snake case for globals

Gotta live the Ocaml_case

I took a CS class that was java based, and now my go-to is Pascal for file names. Sometimes I do flat or screaming just 'cause.

my go_to NamingCovention: ANYTHING but camel-case 🤮

camel for java. flat for c

I use PascalCase for classes, camelCase for functions and variables, SCREAMINGCASE combined with snake_case for constants and for filenames/folders mostly snake_case with kebab-case if date or timestamp is involved.

Snake Case and Pascal Case is what I tend to default to

Kebab case with Pascal case in the usual places. I'd change to all kebab case but the muscle memory of typing Documents would nearly kill me.

I do kebab with underscores.

If its my own personal code, snake case, if I am sharing with my frontend devs then camel case. If I am writing short scripts, then flat.

Related: a list and explanation of variable naming conventions https://www.pluralsight.com/blog/software-development/programming-naming-conventions-explained

camelCase for non-source-code files. I find camelCase faster to "parse" for some reason (probably just because I've spent thousands of hours reading and writing camelCase code). For programming, I usually just use whatever each language's standard library uses, for consistency. I prefer camelCase though.

depends on the color of my mood ring

Pascal for server code running C# and Camel for client running TypeScript.

Pascal and Kebab case

generally i still to camelcase if i have no separators, if i do have separators i stick to - now. _ sucks. I use . notation when dealing with copies of files.bak or something like that.

If i feel really special i throw a space in the name just because

I use camel case for methods and functions and snake case for variables. And pascal case for constants. Why? I don’t really know, it makes for a nice distinction I guess.

Pascal or Camel are best cases

• Media: Cool_file_name
• Other: cool-file-name