Looking for both a date and authoritative reference. Expected answer sometime in the 1960's.
This information is essential for writing an impactful feature request.
When were background processes invented
background-processhistory
Related Solutions
I have not followed closely the history, but there was no big bang, only evolution. There were large software repository on the net in the early nineties, and probably even in the eighties. The archive CTAN for TeX started in 1992. Hobbes for OS/2 started around the same time, I think. There were some for Linuxes, for BSD Unices, for Windows, for TCL/Tk ... In the mid nineties they became available on DVD as many people did not get enough bandwidth to download from FTP archives. (company names include Infomagic, Pacific High tech, Walnut Creek, Prime Time Freeware, ...). Linux existed in distributions, and still does. People could download very early, if they had the bandwidth. Well organized packaging came progressively ... and required developping standards. The early packaging systems could not manage dependencies, and removing a package was a risky business. Keeping track of what was installed came in. And things slowly improved. Not that slowly when you think of it.
I should add that much of the technology relies on version management techniques that started evolving in the early eighties (probably late seventies), but not over the network. Possibly the earliest tool in that line is make, designed by Stuart Feldman in 1977 at Bell Labs, and allegedly produced in a single night.
In your example the combine command will just be run as soon as the subshell exits (and provided the last background process was started without an error). The subshell will exit immediately after the jobs are started since there is no wait command.
If you want to execute a command based on the return value of two or more simultaneous background processes, then I can't see any other way other than to use temporary files for the return values. This is because wait can only return the return value of one of the processes it waits for. Also since the background processes must be run in subshells to get their return values at all, they cannnot be stored in variables. You could do:
something InputA >IrrelevantA &
something InputB >IrrelevantB &
tmp1=$(mktemp)
tmp2=$(mktemp)
( somethingElse InputA >OutputA; echo $? >"$tmp1" ) &
proc1=$!
( somethingElse InputB >OutputB; echo $? >"$tmp2" ) &
proc2=$!
wait "$proc1" "$proc2"
read ret1 <"$tmp1"
read ret2 <"$tmp2"
[ "$ret1" = 0 && "ret2" = 0 ] && combine OutputA OutputB >Result
rm "$tmp1" "$tmp2"
If you don't really care about the return values, you can just start the jobs normally and use wait:
something InputA >IrrelevantA &
something InputB >IrrelevantB &
somethingElse InputA >OutputA &
proc1=$!
somethingElse InputB >OutputB &
proc2=$!
wait "$proc1" "$proc2"
combine OutputA OutputB >Result
Best Answer
The first system to support multiple concurrently-executing processes, or at least to simulate the concurrent execution of multiple processes, was the Atlas system developed at Manchester University in the UK in the early sixties. The reference for that is the paper describing the system, The Atlas supervisor, written by Tom Kilburn, R. Bruce Payne, and David J. Howarth, and published in 1961 at the AFIPS Computer Conference:
Processes waiting for data are suspended and placed in the background until the data is available.
You can find out more about the Atlas system and the history of operating systems in Per Brinch Hansen’s The Evolution of Operating Systems. His Classic Operating Systems book reprints quite a few pioneering papers, including the Atlas paper referenced above.
The concept of multi-programming, as described above, was first described by Christopher Strachey in his 1959 paper, Time sharing in large, fast computers.
What eventually became remembered as time-sharing wasn’t quite the same as the above; time-sharing, which might be more familiar to people used to modern multi-user, multi-tasking systems, was invented in 1959 by John McCarthy at MIT; see The Evolution of Operating Systems for references. The first system demonstrating time-sharing was CTSS, in late 1961 on an IBM 709, described in An experimental time-sharing system, written by Fernando Corbato, Marjorie Merwin-Daggett, and Robert C. Daley, published in 1962. CTSS already had daemons which might qualify as the earliest form of background processes (in the modern sense of that phrase).
See also The history of context switch on Retrocomputing, and John McCarthy’s own Reminiscences on the history of time sharing.
If you’re referring to background processes from a shell perspective, they appeared along with job control in the C shell, where Jim Kulp implemented it sometime around 1980 (the feature was available in 4BSD, released in late 1980).