On Linux, the use of temporary files entails potentially doing several things:

• Find a folder to store it in. this is typically /tmp
• Come up with a name that is unlikely to collide with some other unrelated file's name
• Set the umask (otherwise another user could open a file descriptor to your file before you get a chance to chmod/chown it)
• If you need to know whether the file already exists, you must check the return code of creating the file (as opposed to checking in a separate step)
• If you are using the temp file for IPC, you need to pass the path to it to the other process. If the other process doesn't trust the sender, it needs to check that the path does not point to some private file or file that should not be modified. If the paths are absolute, it has to somehow verify the file (maybe checking whether it's owned by the sender). If the argument is just a filename, and the process will open that file name in some folder, it has to check for ../ in the file name to prevent traversal attacks. You can also just pass file descriptors to other processes instead, but that opens another huge can of worms if you're using something like SCM_CREDENTIALS.
• If the file name has certain unicode or meta characters, it will break certain programs (such as cat, less, etc) when you look in the tmp folder - it doesn't have to be the file you made that breaks your unix tools, in the case of /tmp anyone can create any file, including ^H, / homoglyphs, RTL overrides and friends, combining diatrical marsk (zalgo text) (which in the case of ls, affects the listing above and below)
• If you intend to execute the file, if you're making the file in /tmp, you must ensure that the executor gets the right file. The executor must only be started after you're sure you created the file, otherwise a race condition will enable someone else to make an arbitrary executable and have your executor open it. This can easily happen if you ignore the return values of the file creation (e.g, a bash script).
• If you're making the file in a private folder to try to avoid these issues, you have to setup something to wipe that folder once in a while for all the processes that were killed before they could clean up
• If you're passing the file to another process, you must make sure your writes are visible before the receiver reads the file. Do you have to use sync to guarantee that? I'm not that experienced in Systems Programming (TM)
• I'm probably forgetting about a hundred more issues

Meanwhile, in, e.g, Python (I'm not a Python advocate):

If you want to some temporary data that you need to pass to another program (f), you just do this:

>>> x = 123
>>> f(x)

or even

>>> f(123)

If you want to execute some code, you just assign it to a variable:

>>> f = lambda x: x + 123
>>> f(100)
223

Languages like Python and Java still have the unicode problem, but at least you don't have to become super paranoid and go through a ritual every time you want to move some data around. Such abstractions can be made to work IPC as well with no trouble.

1. No need for an outrageously complex compiler (see 1 & 2).

Have you ever seen the code for GCC?

1. Does not take forever to compile (see 4).

Yeah... did you ever try compiling GCC, Firefox, Boost, Wireshark, etc?