I want to describe a software task (unit of work) that could take a long time, either because it's a lot of operations (processing time) or because it has to do communication with the network and there will be some waiting involved due to latency of the communication before the task can finish.

Without making the question too technical, let's use the analogy of a person who has to do a job that will take a long time, not necessarily because it's a lot of work, but because there are uncertainties in how long it will take to get the work done.

A lengthy task is close to what I want. However, I'm hesitant that it might convey more the "hard work" meaning (lots of work), and readers won't think of the other case (where latency is the reason it takes long). Is there a single-word adjective to capture this idea?



It was a time-consuming process, so he hired a professional to do it.

Closer to software:

Time-consuming operations should be run in separate background tasks.

Edit: Android calls them longer-running, meaning CPU-intensive and/or blocking:

A Service is an application component representing either an application's desire to perform a longer-running operation while not interacting with the user or to supply functionality for other applications to use. [...] if your service is going to do any CPU intensive (such as MP3 playback) or blocking (such as networking) operations, it should spawn its own thread in which to do that work.


Resource-intensive (1,2) probably is as close a term as is available. Terms like cpu-bound, I/O-bound, and network-bound apply to specific resource-intensive jobs.

When latency is important, consider latency-limited, communication-bound, and non-distributable.

  • Thanks for the suggestions. Since you seem to grok the lingo, I'll add the problem is with tasks that should not run on the UI thread. It's bad to block the UI thread for too much time, and it doesn't matter what the reason is. – Fuhrmanator Mar 24 '13 at 1:01
  • You might say, "Don't run background tasks on the UI thread". I've seen some label like (but different from) "response-killer" applied to over-lengthy tasks too. But “Don’t run response-killers on the UI thread” doesn't quite work – James Waldby - jwpat7 Mar 24 '13 at 1:05

The process of writing Data Transfer and Data Access objects are simple but terribly tedious. And Oh, having to translate existing ones from obsolete HBMs to annotated classes is absolutely horrendous tedium.

tedious [ˈtiːdɪəs]

  • Tiresome by reason of length, slowness, or dullness; boring.
  • causing fatigue or tedium; monotonous
  • Obsolete progressing very slowly

protracted: lasting for a long time or longer than expected or usual. may be an option, or any of its synonyms:






If you want to describe a work or process that is slow moving, bulky, comprises of a lot of processing and thus time taking, you should go for the word "cumbersome".

Cumbersome :

(3) slow-moving

Eg: The application process is cumbersome and thus, inefficient.

  • I would understand cumbersome to relate to an object that is large and unwieldy, awkward - difficult to manipulate or move, rather than latent... – NeilB Oct 29 '19 at 22:36

ar·du·ous /ˈärjo͞oəs/

adjective involving or requiring strenuous effort; difficult and tiring. "an arduous journey"

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.