Really wish windows and Linux had the same 4 modifier system as Mac, always feels like ctrl is overloaded on Linux and alt wrongly used as a ctrl key in weird scenarios on windows (alt+F4)
Well, I say "is used", but nothing in Windows is consistent anymore. Especially since web browsers started disrespecting the OS shortcuts. Now it seems like every application follows the web browser UI conventions instead of OS ones.
Well, if we're talking about traditional Windows behavior, there's no such thing as an app in the first place.
Some programs allowed multiple windows to be open at the same time (e.g. Notepad), and some didn't (e.g. Paint), but for those that did, they spawned each window as its own process. Closing the window closed the process. That two processes shared the same executable had no deeper meaning until Windows XP added taskbar grouping.
Except Excel, which wants to act like single application with multiple windows.
For GUI apps it sends a WM_CLOSE, because that's they way to "close" a GUI application.
For console applications it sends a message through the "Console control handler". Which the console subsystem no longer lets the application properly handle and kills the process summarily anyway.
Note that I keep saying "application" because that has been the terminology in windows forever. "GUI apps" and "console apps" were a thing before mobile.
In 16-bit land, WinMain is an application entrypoint, and launching an already-open application again causes its WinMain to be invoked with hPrevInstance set to a non-NULL value. Here, the distinction between "process" and "application" was nonexistent/irrelevant.
In 32-bit land, WinMain is a process entrypoint, hPrevInstance is always NULL, and launching an already-open application again causes a new process to be spawned by the O/S. If the application wasn't coded for explicit coordination (using O/S-level mutexes or IPC mechanisms), then two or more running copies of the same application are not aware of each other, do not share any resources, and for a long time were not treated as a single "application" by the operating system.
The way I view this, there are three separate things: processes, applications, and windows. In all versions of Windows, a single process/application, that the user launched exactly once, was able to have one main window and multiple other windows that could be independently manipulated, closed etc. Since Alt+F4 was added as a keyboard shortcut, it closed the currently active window, which might happen to be a confirmation dialog or anything else. If it was used to close the main window, the application/process might choose to shut down, automatically closing other windows it owned, but this was never a requirement.
Now, for the process / application distinction. By my understanding, in traditional Windows, the concept of an application is essentially an executable whose main function is WinMain. A user can spawn one or more processes from the same application executable, and these are handled differently in 16-bit vs 32-bit Windows - but they have always existed as separate copies, within the technical limitations of the time. Even in Windows 1.0, the second execution of WinMain did indeed receive a hPrevInstance and could use it to access resources of the already running instance - but it was still a separate thing, with its own window and its own event loop. Ultimately it wasn't all that different from a new process spawned from the same executable - except that memory and compute constraints at the time made it important to have a way to share certain parts of the parent (and the lack of memory isolation made it trivial to access the memory of any other thing running on the system anyway).
The concept that an application can only have 0 or 1 instances running is a very weird concept that MacOS shares only with mobile OSs and Windows Metro/Universal/UWP/whatever MS calls their mobile-style store apps today.
Edit to add a note: it's actually quite common on Windows today for programs to not actually launch, or at least not use, a second process when running the executable again. What they do instead is that during startup they check if the process is already running by checking some named mutex or other similar mechanism, and if it is, they ask that process to open a new top-level window, maybe with the new document loaded into it if you were actually opening a doc, and then the new process just exits, while the old process start a new window that for all intents and purposes looks just like a new copy of the process to the user.
Now, Alt+F4 didn't exist as a standard keyboard shortcut in Windows 1.0 - it was added later, but certainly by Windows 95 at the latest. And already in Windows 95, Alt+F4 was the "Close Active Window" shortcut, which would close the window or dialog that was currently active - not the entire application whose window this was. So pressing Alt+F4 on your keyboard while a "Save As" dialog was present in Word 95 would close that "Save As" dialog, it wouldn't close your Word document.
You can check the Windows Programming Guide to see how to create dialog windows or popup windows in the same app that already had a main window in Windows 1.03: https://archive.org/details/win103-sdk-manuals/5%20-%20Windo...
“Other than copy and paste”
Is like saying “other than the most used shortcuts ever”
Feels much better on MacOS where you have ctrl for things within the terminal and cmd for things at an OS/window level.