What is backend processing?
Backend processing is so common you probably never knew it has a name.
Did you ever place an order at a 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, passes the sack back to the kitchen manager 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. If we need three cooks for meat and one cook for vegetables, it's simple to do.
- 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 tasks with no central management. They soon discover that:
- they are overwhelmed with tasks
- the task create/destroy overhead degrades their processing
- abnormally terminating tasks have no recovery
- common storage cannot be shared among tasks
- 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 tasks. Your applications are efficient, scalable and simple.