22

The Unix touch command is used to update a file’s access time and modification time, or to create (misspelled creat in the system call) a new file.

Since English isn’t my first language, I’ve always wondered why this kind of action is called touch.

The word makes me think of Michelangelo’s The Creation of Adam, where God and Adam reach out and their fingers nearly touch. In that moment, touch seems to carry a sense of creation.

While reading Seven Languages in Seven Weeks recently, I saw a Scala example explaining mutable vs. immutable data. In that context, touch also seemed to suggest a small change or update.

scala> var mutable = "I am mutable" mutable: java.lang.String = I am mutable scala> mutable = "Touch me, change me..." mutable: java.lang.String = Touch me, change me... scala> val immutable = "I am not mutable" immutable: java.lang.String = I am not mutable scala> immutable = "Can't touch this" <console>:5: error: reassignment to val

I’m not sure I fully understand the nuance. Would love to hear how native speakers or longtime Unix users interpret the choice of the word.

Improve this question
10
  • 5
    In the painting, the 'touch' is surely an update - the body had been created, and then the touch imbued it with life. Commented Jun 11 at 11:52
  • 20
    You’re overthinking this – “touch” just refers to the everyday meaning of the word, as in handle, but not substantially change. Commented Jun 11 at 12:04
  • 15
    As a small aside, note that creat is not a misspelling per se, but a consequence of the behavior of some linkers from back then (names could only go up to 6 characters including a prefixing underscore, hence 5 characters for creat): unix.stackexchange.com/questions/10893/… Commented Jun 11 at 18:23
  • 2
    that file wasn't touched in weeks, is it still up-to-date? maybe just english language inspired Commented Jun 12 at 7:54
  • 3
    And then there is the question that can trouble innocent minds: Can a shell script touch itself?? Commented Jun 12 at 11:45

5 Answers 5

Reset to default
48

In Unix history, touch was introduced in V7, and that’s also the version that introduced make. I’ve always thought of them as related, and the V7 make man page mentions touching files with the same meaning as touch (with the -t option), and references the touch man page. Stuart Feldman’s original Make paper also mentions touching files, and shows a recipe using touch to update what we’d now call a phony target (print) — and that’s still a common use in Makefiles (using “stamp” files). In that context, I think of touching a file as prodding it, indirectly prodding related build recipes in Make, or more generally prodding the build. To me, that context also explains touch’s double effect (updating a file’s last modification date, creating the file if necessary): if you want Make to apply a recipe, the recipe’s prerequisites must both exist and be newer than the target; if you want Make to ignore a recipe, the recipe’s target must both exist and be newer than the prerequisites.¹

That explains touch’s features, but it doesn’t explain why it’s called touch. Referring to English itself, another way of thinking of “touch” with a similar meaning to the touch utility is in reference to a body of work in general. “I haven’t touched this project in a while” isn’t the same as “I haven’t used this project in a while”: touching a project (whether it’s a project on a computer, or DIY, or a painting, or whatever) implies some level of modification, if only minor (like re-arranging paintbrushes before deciding you can’t actually be bothered painting that day). In that sense, a file’s last modification time indicates when it was last touched, and therefore a utility to update a file’s last modification time would naturally be referred to as touching the file — touch.

¹ A simpler explanation of this feature of touch could just be that a file must exist to have a last modification timestamp, so perhaps I’m reading too much into this make association. Incidentally, there are two circumstances in which V7 touch creates files: the first is when a file doesn’t exist, the second is when a file is empty — there was no “update timestamp” system call in V7, so touch did its job by reading a byte and writing it back; that’s impossible in an empty file, and touch calls creat() on those instead.

Improve this answer
4
  • 24
    Agree - it's unremarkable English usage. "Who changed this file?" "Wasn't me, I haven't touched it!". Commented Jun 11 at 11:47
  • 3
    There is also the related English word "untouched", which the dictionary maps to "unaltered" but that means the same as "unmodified". As touch updates the modification time, this also matches perfectly. Commented Jun 12 at 11:58
  • 1
    @dave: Interestingly, there's a quote about programmer etiquette around Unix tool maintenance by a member of the original Unix Lab that supports the everyday meaning angle. "[T]here was this attitude that he who touched it last owned it." Lorinda Cherry Commented yesterday
  • 1
    @NickWestgate - that's pretty common; at least, where I work, he who touched it last is the natural recipient of the next bug to be reported. Commented yesterday
16

Touching an object often will leave it altered. A fingerprint or smudge of dirt is left on its surface; an indentation is left in the surface of a soft material like clay, powder, or sand; a solid object can be moved or tipped over.

When you view the filesystem to be the object receiving the touch, the above analogies are pretty clear. Especially the fingerprint/smudge.

Improve this answer
4
  • 2
    Honestly, this is a bad analogy, possibly harmful for understanding. How can you see that a file has been touched rather than just created? It's not dirty, smudged, changed in any way. There's no difference between a pristine file you just created, and that file after using touch. You may just have created that same file at a later time. Commented Jun 12 at 10:58
  • @pipe touch just calls open() on the file path. whether or not it previously existed is a problem for the kernel, so it is a "side effect" that touch creates files to begin with. Commented Jun 13 at 8:00
  • @Themoonisacheese I think you maybe redirected that to the wrong person. If you use "@..." it's as if you direct it to me but I don't see how your comment is related to what I wrote? Commented Jun 13 at 14:37
  • 1
    @Themoonisacheese we have the source code of the original touch implementation, and it handles creation explicitly; it’s not a side-effect. Commented Jun 13 at 15:38
8

A very natural way of describing a file's modification time is to say it's the most recent time you have touched that file. If you want a program that does nothing but touch a file so that its modification time will be updated, you might call it 'touch'. And a file has to exist to be touched, so that's why it creates a file. I really think that's all there is to it.

(I edited based on the comments.)

Improve this answer
7
  • But touch by default updates the last modification time, not the last access time (and the initial version didn’t have options to change that). Commented Jun 12 at 10:07
  • @StephenKitt It's the original Unix convention: "a program should do one thing well". Unfortunately, well-designed programs by this criterion are fertile ground for weedy options to grow... Commented Jun 12 at 11:24
  • @JohnDoty I know — but since the question is about why the utility ended up named touch in the first place, behaviour added later seems irrelevant. Commented Jun 12 at 12:10
  • @StephenKitt you can look at something without touching it. Commented Jun 13 at 10:52
  • 1
    @StephenKitt oh I see - I thought the issue was about the reason for it being "touch" but now I understand it's just that the answer says "access" instead of "modification". I've submitted a suggested edit to the answer to fix that. Commented Jun 13 at 12:49
7

Meaning of touch

  • A touch describes in (common) English the slightest possible contact with an object/modification of an object.A contact always exerts a force.

  • In context of a file exerting force means writing

  • The slightest form of writing is not changing anything except recording that it was changed. Any other 'larger' operation would change more than this.

  • The only form of less change would be to change the access date. Just this would not be an equivalent of touching (i.e. writing) but looking at (reading) - and look being a proper name for such a command.

  • Also, an object must exist to be touched (noone can touch an imaginated thing), thus touch has to leave an existing file entry as well.

Relation to open/creat(e)

  • open() and creat() are system calls (thus noted in manual section 2 - see man open), intended for use in (c) programs, not on command line. They deliver a file handle so the program can operate (read/write/etc.) thereon.

  • touch is an executable programs or shell commands to be used on command line (or in shell scripts). It performs some operation on user level. It's documented, like any other shell command, in manual section 1 (try man touch).

  • touch uses system calls like open() to perform it's duty.

    (IIRC gnu's touch first opens the file using open() (or openat() for directories) to get a file descriptor followed by futimens(). Using an fd (and openat()) simplifies path related operations.)

Also

creat() isn't misspelled, but abbreviated. The minds behind Unix weren't about who created the longest function names, but compact readable code. You will note that there are quite a lot of those system calls that could have had long names were shortened to (around) 5 characters. Think lseek() instead of long_seek(), fcntl() instead of file_descriptor_control() or fchmod()instead of change_mode_bits_by_file_descriptor(). That name length madness is of a somewhat later development :))

Improve this answer
10
  • 3
    'A touch' may be a slight thing, but it doesn't follow that 'to touch' is necessarily slight. After you've broken something with your heavy-handedness, I might well retort "I told you not to touch it". /signed/ An Englishman. Commented Jun 11 at 20:56
  • 2
    I'm going to have to assert nationality on this one. Commented Jun 11 at 21:59
  • 2
    "The minds behind Unix weren't about who created the longest function names, but compact readable code." Many of us computer users from the 1970s were still using clunky electromechanical terminals, so not typing extra characters was a bonus. Commented Jun 12 at 2:41
  • 2
    Ken Thompson was once asked what he would do differently if he had to do it again. He said "spell creat with an e". He meant two e's of course. It's the most annoying abbreviation in the whole of Unix. Commented Jun 12 at 7:45
  • 1
    @phuclv - the length of a command should be inversely proportional to how often you need to type it. Commented Jun 12 at 17:45
5

The real explanation, I think, is that it is named for what you'd use it for, rather than how it does it.

make rebuilds targets for which the source has been touched, in the loose sense of the word. touch adds a way to do that explicitly.

Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.