What is backend processing?
Backend processing is so common you're probably unaware it has a name.
A common example of backend processing is the take-out restaurant. The clerk taking
your order is not the person filling that order.
The clerk passes the order to a kitchen manager.
The kitchen manager separates the order into its component parts
(meat, potatoes, vegetable) and places each component request into a queue for processing
by a separate cook.
As each cook finishes a dish, the cook places the dish into a sack and
then fetches the next request from the queue.
When the order is complete, the kitchen manager passes the sack to the
clerk who gives it to you.
The benefits are:
- Efficiency -- The order is filled in parallel. All components are cooked
simultaneously.
- Scalability -- During heavy loads, the kitchen manager can easily add more cooks
exactly where they are needed.
- Simplicity -- Each cook only needs to understand one type of dish. A veggie cook
doesn't need training in meat.
Front-end processing is the way most software operates.
- The clerk (GUI or command line parser) cooks (single threads) one component at a time
(linear programming.)
- When the first component finishes cooking (computing), the second may start.
- The next order may not start until all components of the prior order finish.
The disadvantages are:
- Inefficient -- The order is filled linearly. Nothing can move until the component
ahead completes.
- Expensive -- The only way to process more orders is to hire and extensively train
more clerks. (Often called "throwing hardware at the problem.")
- Complex -- Each clerk must know all aspects of the system (human interface,
accounting, all component cooking skills, etc.)
Some developers try backend processing without the kitchen manager. They create threads*
(cooks) with no central management. They soon discover that:
- They are overwhelmed with threads*.
- The thread* create/destroy overhead degrades processing.
- Abnormally terminating threads* have no recovery.
- Common storage cannot be shared among threads*.
- Some functions need timing while others need autonomous processing.
- The list goes on and on.
Backend software development with Tymeac™
is like the well run restaurant.
Tymeac™ is the kitchen manager. The
cooks are separate, single purpose threads.* Your applications are efficient,
scalable and simple.
