Batching: A design pattern for efficient and flexible client/server interaction

Francisco J. Ballesteros, Fabio Kon, Marta Patiño, Ricardo Jiménez, Sergio Arévalo, Roy H. Campbell

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

The Batching design pattern consists of a common piece of design and implementation that is shared by a wide variety of well-known techniques in Computing such as gather/scatter for input/output, code downloading for system extension, message batching, mobile agents, and deferred calls for disconnected operation. All techniques mentioned above are designed for applications running across multiple domains (e.g., multiple processes or multiple nodes in a network). In these techniques, multiple operations are bundled together and then sent to a different domain, where they are executed. In some cases, the objective is to reduce the number of domain-crossings. In other cases, it is to enable dynamic server extension. In this article, we present the Batching pattern, discuss the circumstances in which the pattern should and should not be used, and identify eight classes of existing techniques that instantiate it.

Original languageEnglish (US)
Title of host publicationTransactions on Pattern Languages of Programming I
EditorsJames Noble, Ralph Johnson, Uwe Zdun, Eugene Wallingford
Pages48-66
Number of pages19
DOIs
StatePublished - Dec 1 2009

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume5770 LNCS
ISSN (Print)0302-9743
ISSN (Electronic)1611-3349

Fingerprint

Batching
Design Patterns
Client/server
Servers
Mobile agents
Interaction
Mobile Agent
Scatter
Server
Computing
Output
Vertex of a graph

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Ballesteros, F. J., Kon, F., Patiño, M., Jiménez, R., Arévalo, S., & Campbell, R. H. (2009). Batching: A design pattern for efficient and flexible client/server interaction. In J. Noble, R. Johnson, U. Zdun, & E. Wallingford (Eds.), Transactions on Pattern Languages of Programming I (pp. 48-66). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 5770 LNCS). https://doi.org/10.1007/978-3-642-10832-7_2

Batching : A design pattern for efficient and flexible client/server interaction. / Ballesteros, Francisco J.; Kon, Fabio; Patiño, Marta; Jiménez, Ricardo; Arévalo, Sergio; Campbell, Roy H.

Transactions on Pattern Languages of Programming I. ed. / James Noble; Ralph Johnson; Uwe Zdun; Eugene Wallingford. 2009. p. 48-66 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 5770 LNCS).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Ballesteros, FJ, Kon, F, Patiño, M, Jiménez, R, Arévalo, S & Campbell, RH 2009, Batching: A design pattern for efficient and flexible client/server interaction. in J Noble, R Johnson, U Zdun & E Wallingford (eds), Transactions on Pattern Languages of Programming I. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 5770 LNCS, pp. 48-66. https://doi.org/10.1007/978-3-642-10832-7_2
Ballesteros FJ, Kon F, Patiño M, Jiménez R, Arévalo S, Campbell RH. Batching: A design pattern for efficient and flexible client/server interaction. In Noble J, Johnson R, Zdun U, Wallingford E, editors, Transactions on Pattern Languages of Programming I. 2009. p. 48-66. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-642-10832-7_2
Ballesteros, Francisco J. ; Kon, Fabio ; Patiño, Marta ; Jiménez, Ricardo ; Arévalo, Sergio ; Campbell, Roy H. / Batching : A design pattern for efficient and flexible client/server interaction. Transactions on Pattern Languages of Programming I. editor / James Noble ; Ralph Johnson ; Uwe Zdun ; Eugene Wallingford. 2009. pp. 48-66 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{75fdb3f7fa7b48689584b1ff8db8c602,
title = "Batching: A design pattern for efficient and flexible client/server interaction",
abstract = "The Batching design pattern consists of a common piece of design and implementation that is shared by a wide variety of well-known techniques in Computing such as gather/scatter for input/output, code downloading for system extension, message batching, mobile agents, and deferred calls for disconnected operation. All techniques mentioned above are designed for applications running across multiple domains (e.g., multiple processes or multiple nodes in a network). In these techniques, multiple operations are bundled together and then sent to a different domain, where they are executed. In some cases, the objective is to reduce the number of domain-crossings. In other cases, it is to enable dynamic server extension. In this article, we present the Batching pattern, discuss the circumstances in which the pattern should and should not be used, and identify eight classes of existing techniques that instantiate it.",
author = "Ballesteros, {Francisco J.} and Fabio Kon and Marta Pati{\~n}o and Ricardo Jim{\'e}nez and Sergio Ar{\'e}valo and Campbell, {Roy H.}",
year = "2009",
month = "12",
day = "1",
doi = "10.1007/978-3-642-10832-7_2",
language = "English (US)",
isbn = "3642108318",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
pages = "48--66",
editor = "James Noble and Ralph Johnson and Uwe Zdun and Eugene Wallingford",
booktitle = "Transactions on Pattern Languages of Programming I",

}

TY - GEN

T1 - Batching

T2 - A design pattern for efficient and flexible client/server interaction

AU - Ballesteros, Francisco J.

AU - Kon, Fabio

AU - Patiño, Marta

AU - Jiménez, Ricardo

AU - Arévalo, Sergio

AU - Campbell, Roy H.

PY - 2009/12/1

Y1 - 2009/12/1

N2 - The Batching design pattern consists of a common piece of design and implementation that is shared by a wide variety of well-known techniques in Computing such as gather/scatter for input/output, code downloading for system extension, message batching, mobile agents, and deferred calls for disconnected operation. All techniques mentioned above are designed for applications running across multiple domains (e.g., multiple processes or multiple nodes in a network). In these techniques, multiple operations are bundled together and then sent to a different domain, where they are executed. In some cases, the objective is to reduce the number of domain-crossings. In other cases, it is to enable dynamic server extension. In this article, we present the Batching pattern, discuss the circumstances in which the pattern should and should not be used, and identify eight classes of existing techniques that instantiate it.

AB - The Batching design pattern consists of a common piece of design and implementation that is shared by a wide variety of well-known techniques in Computing such as gather/scatter for input/output, code downloading for system extension, message batching, mobile agents, and deferred calls for disconnected operation. All techniques mentioned above are designed for applications running across multiple domains (e.g., multiple processes or multiple nodes in a network). In these techniques, multiple operations are bundled together and then sent to a different domain, where they are executed. In some cases, the objective is to reduce the number of domain-crossings. In other cases, it is to enable dynamic server extension. In this article, we present the Batching pattern, discuss the circumstances in which the pattern should and should not be used, and identify eight classes of existing techniques that instantiate it.

UR - http://www.scopus.com/inward/record.url?scp=76749104708&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=76749104708&partnerID=8YFLogxK

U2 - 10.1007/978-3-642-10832-7_2

DO - 10.1007/978-3-642-10832-7_2

M3 - Conference contribution

AN - SCOPUS:76749104708

SN - 3642108318

SN - 9783642108310

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 48

EP - 66

BT - Transactions on Pattern Languages of Programming I

A2 - Noble, James

A2 - Johnson, Ralph

A2 - Zdun, Uwe

A2 - Wallingford, Eugene

ER -