Time-sharing and batch processing implies for me serving multiple users. (And are more dated. It looks like speak of the 70’s or the 80’s)

Multi-tasking and serial processing haven’t that implication.

But if someone makes a nuance between the two, I’d expect them to explicit it.

In computing TIME-SHARING is described as being the sharing of computing resource among many users by means of multiprogramming and multi-tasking. So in effect by allowing many users to interact concurrently with a single computer. There are many systems like this already built Stanford PDP-1, Univac, IBM TSO and so on.

MULTI-TASKING on the other hand is the method where multiple tasks(processes) are performed during the same period of time. This can be achieved on single CPU by creating the proper scheduling strategy for context switching. On multi-cpu they can run each on an individual CPU or again use a strategy to run more tasks than the number of CPU’s.

In time sharing systems the scheduling strategy for context switching is done by interrupts usually. Time sharing systems basically where first introduced to name computers shared among multiple users through terminals.

Multi-tasking usually implies multiple threads. With multicore systems that means each thread will run in it’s own core or with multi-processor systems on it’s own processor.

Time-sharing clearly implies one single thread that serves several task as you defined.

However, there may not be such a clear definition anywhere … this is just what usually is understood about this 2 different expressions.

Also, I imagine that multi-tasking is from a higher point of view, it refers to a user being capable of running several applications simultaneously. The user doesn’t know the underlying technology. It can be real multi-threading or time-sharing or something different.

Time-sharing is more of a technical term which refers to the functioning of a system. This is usually more used by programmers or sysadmins and less by users, who actually don’t care about how their computer works.

I hadn’t been born when these terms were invented, but I always understood them as the two sides of the same coin. The machine (and its operating system) has to run multiple tasks in order to let the users share their machine time. So I believe the difference is in the perspective, one is the user’s, the other is the machine’s (or the OS programmer’s).

It may be late to answer, nevertheless, it will help some ones having difficulty in grasping the subject.

Each CPU core can execute one process at a time.

Excerpt From:
Operating System Concepts 10e, Abraham Silberschatz

On the other hand,

Time-sharing makes an illusion that more than one process can execute
simultaneously, even though there maybe only one physical CPU, single
process.

Excerpt From: UNIX Systems Programming: Communication, Concurrency
and Threads: Communication, Concurrency and Threads (2nd Edition)

I don’t remember how many times I read the two definitions only ALLAH(s.w.t.) knows! to comprehend them. Because it sounds very contradictory. Fortunately, the latter book exemplify it. I think it pays reading off.

Consider the following analogy. Suppose a grocery store has several
checkout counters (the processes) but only one checker (the CPU). The
checker checks one item from a customer (the instruction) and then
does the next item for that same customer. Checking continues until a
price check (a resource request) is needed. Instead of waiting for the
price check and doing nothing, the checker moves to another checkout
counter and checks items from another customer. The checker (CPU) is
always busy as long as there are customers (processes) ready to check
out. This is multiprogramming. The checker is efficient, but
customers probably would not want to shop at such a store because of
the long wait when someone has a large order with no price checks (a
CPU-bound process). Now suppose that the checker starts a 10-second
timer and processes items for one customer for a maximum of 10 seconds
(the quantum). If the timer expires, the checker moves to another
customer even if no price check is needed. This is timesharing. If
the checker is sufficiently fast, the situation is almost equivalent
to having one slower checker at each checkout stand. Consider making a
video of such a checkout stand and playing it back at 100 times its
normal speed. It would look as if the checker were handling several
customers simultaneously.

Though I still can’t comprehend or imagine the video part of the example, I get almost.