Do we “exit”, “quit” or "close" an application?

  • Do we “exit” an application, do we “quit” an application, do we “close” an application?

    This is in relation to a desktop app. What is the most meaningful term to use?

    Windows command line ftp client may be instructive here (or not): You "close" the connection, then "quit" the client, then "exit" the command window!

    I like to "terminate" and "shut down" applications. Sounds powerful >:)

    I kill applications.

    @simon - What do you feel when you kill applications?

    @simon killing an application has a very specific meaning for an application developer: it is ending the application with brute force (ie through the task manager) instead of using the application's options to end its execution.

    And when you absolutely, positively need to get the job done: 7-pass zero-fill format :)

    The majority of non-developer computer users seem to prefer "X out".... not that you should adopt their customs :)

    Sometimes, I endlessly minimize an application to the task bar... (just don't be one of those programs, and we can be friends).

    For a normal user, aren't they synonyms when applied to desktop programs?

    @MarjanVenema: It all depends … Sending e.g. `kill -TERM` to an application that handles signals properly would shut it down in a proper way.

    @Sukminder: hmm, maybe. I also know of "proper signal processors" that do the same on receiving a stop or quit. Most of the time a kill command sent to any server type application is used to forcefully shut down a connection to the server that is causing some kind of trouble and not to shut down the server itself. For a "shut down yourself nicely" command "kill" is not very good name.

    @MarjanVenema: _arguably_ kill is not a good name for the `kill` utility, as it's sometimes in fact used for signals that don't even have anything to do with ending a process (e.g., request the status of a running `dd` process). Nothing we can do about that... due to its inclusion in unix "kill" has received such a jargon meaning. The only thing that would still sound properly martial to a hacker is "kill-nine".

    I quit my job and exited the shop, just before they closed. Now that we have a visual of how each of those words are used, the answer should become apparent. Personally, I would've asked this question on the English.stackexchange.com website - but meh. It's a good question anyway.

    We close windows or mobile apps, or connectins. We quit VIM. We command-Q Mac apps, and I think we alt-X to exit Windows apps? If you are designing a desktop app, it's usually best to stick with the existing patterns in place for that operating system.

    Exit = generic term; quit = a non-technical term for killing the process (Mac); close = close the window, the process can still be running; kill = kill the process

  • If you are developing a Windows application, the correct term to use is "Exit". This is spelt out in Microsoft's Design apps for the Windows desktop guide, under the "Standard Menu Bars" section.

    If you are developing a Mac application, the correct term to use is "Quit". (Your menu item must read "Quit AppName".) This is spelt out in Apple's OS X Human Interface Guidelines, under "The App Menu" section.

    In general, you should follow the platform's user-interface guidelines when you are developing apps so that your app is consistent with all other apps in the same platform, so as to reduce your app's complexity and learning curve for your customers.

    In the Windows context, `close`ing the last windows normally `exit`s the application, whereas this does not have to be the case on an Apple OS. Stick to the Interface Guidelines of the OS to provide a consistent experience for your user on the given OS is good advice.

    For Windows, it depends on the context. Typically an app will have **`"Exit"`** on the standard (**`"File"`**) menu, and **`"Close"`** on the system menu. Notpad, Thunderbird, Firefox all have the typical **`"File"`->`"Exit"`**, and **`"System-menu"`->`"Close"`**. But there are exceptions. Windows Explorer (at least on Win 7) has **`"File"`->`"Close"`**, and **`"System-menu"`->`"Close"`**. Command prompt (**`"cmd.exe"`**) has **`"System-menu"`->`"Close"`**, and you type **`Exit`** to **`Quit`/`Close`/`Exit`**. As you recommend, it's best to stick with the standards for the OS.

    @Kevin Which makes perfect sense, since exiting is something you do from "within" the app, while closing is something you (tell the system to) do from the "outside".

    Also UI guidelines for other OSs might vary: for example, Gnome GUI for Linux explicitly differenciate Closing a window but Quitting an app: https://developer.gnome.org/hig-book/3.10/hig-book.html#the-file-menu

    What a pain in the butt if you are developing a cross-platform application. I can see the branching statements now, `if (isMac()){/*tell user to quit*/}else if(isWin()){/*tell user to exit*/}else{/*you're dealing with an educated user, let them call it what they want*/}`

    @RomanBruckner I disagree there. "Close" on Windows usually means closing the current window or tab only. A good example is Notepad++ on Windows, where there are two separate options on the File menu: "Exit" and "Close." If I click "Exit", all tabs will close, but if I choose "Close" only the active tab will close.

    @nullability however I believe the red X in the upper right of the window chrome is the close button, which will exit the application if clicked.

    @Andy It will exit the application, but only because it's the only window open. If I have multiple windows open, the red X will only close the current window and leave the application running on other windows.

    You will not need branching statements in the code of cross-platform applications, @SnakeDoc, as you probably want to build the UI differently for different platforms. Even for the same platform localised into different languages, you will want to have separate resources, not just to cater to different text, but also to different length of strings that may affect the layout of the UI.

    It would have been good though, if the terminology didn't vary with the platform. A simple way to state it would be that one "Opens" a GUI application and the opposite of it being to "Close" an application. Running an application could refer to an algorithm or a back-end process which is 'run' and then 'terminated' (rather than 'exit' or 'quit').

    @nullability That's true, but its valid to say you're closing the application. The OS is asking the application to close, I think its fair to say exit is internal to the app and close is external.

    @KevinFegan because you never exit Windows Explorer.

    *INSUFFICIENT UNIX IN THE HOUSE*. For UNIX processes at a command-line level, the standard term is `kill`. "Killing" is just as ambiguous as "closing" though -- you can `kill` a process with one of a set of signals, only some of which make it terminate. However, the command `kill -9` is famous for being *totally unambiguous*: It sends the `SIGKILL` signal, which immediately cuts off resource access at `init` level, giving the target process no chance to react.

    @Anko Kill is a term for a different situation and not really UNIX specific in general. Kill is not the normal means of ending the application, but rather by forceful means. For example in Windows the command line tool is called taskkill (hence 'kill' would be an appropriate term for terminating a process in this instance, but not in the normal way, as this question is discussing). In UNIX especially there is also a difference between SIGKILL and SIGTERM. These are indeed UNIX specific and probably only appropriate for programmers or system administrator audiences anyway.

License under CC-BY-SA with attribution


Content dated before 7/24/2021 11:53 AM