multitier programming

The code of the different tiers can be executed in a distributed manner on different networked computers. For instance, in a three-tier architecture, a system is divided into three main layers – typically the presentation, business, and data tiers. This approach has the benefit that by dividing a system into layers, the functionality implemented in one of the layers can be changed independently of the other layers. On the other hand, this architectural decision scatters a cross-cutting functionality belonging to several tiers over several compilation units.

In multitier programming, the different tiers are implemented using a single programming language. Different compilation backends take into account the destination tier (e.g., Java for a server and JavaScript for a web browser). Consequently, a functionality that is spread over tiers can be implemented in a single compilation unit of a multitier program.

At their core, multitier languages allow developers to define for different pieces of code the tiers to which the code belongs. The language features that enable this definition are quite diverse between different multitier languages, ranging from staging to annotations to types. The following example shows an Echo client–server application that illustrates different approaches. In the example, the client sends a message to the server and the server returns the same message to the client, where it is appended to a list of received messages.

service echo() {

var input =

return

var ws = new WebSocket("ws://localhost:" + ${hop.port} + "/hop/ws")

ws.onmessage = function(event) { document.getElemenetById("list").appendChild(

}>

}

var wss = new WebSocketServer("ws")

wss.onconnection = function(event){

var ws = event.value

ws.onmessage = function(event) { ws.send(event.value) }

}

Hop uses staging to embed code that is to be run on the client into a server-side program: Using the ~{…} notation, the code for the onload (Line 4) and onclick (Line 10) handlers is not immediately executed but the server generates the code for later execution on the client. On the other hand, the ${…} notation escapes one level of program generation. The expressions hop.port (Line 5), event.data (Line 6) and input (Line 9 and 10) are evaluated by the outer server program and the values to which they evaluate are injected into the generated client program. Hop supports full stage programming, i.e., ~{…} expressions can be arbitrarily nested such that not only server-side programs can generate client-side programs but also client-side programs are able to generate other client-side programs.

HTML can be embedded directly in Hop code. HTML generated on the server (Line 2–14) is passed to the client. HTML generated on the client can be added to the page using the standard DOM API (Line 6). Hop supports bidirectional communication between a running server and a running client instance through its standard library. The client connects to the WebSocket server through the standard HTML5 API (Line 5) and sends the current input value (Line 10). The server opens a WebSocket server (Line 17) that returns the value back to the client (Line 20). So-called services, which are executed on the server and produce a value that is returned to the client that invoked the service. For example, the echo service (Line 1) produces the HTML page served to the web client of the Echo application. Thus, the code in a service block is executed on the server.

fun echo(item) server {

item

}

fun main() server {

page

}

main()

Links uses annotations on functions to specify whether they run on the client or on the server (Line 1 and 5). Upon request from the client, the server executes the main function (Line 18), which constructs the code that is sent to the client. Links allows embedding XML code (Line 7–15). XML attributes with the l: prefix are treated specially. The l:name attribute (Line 10) declares an identifier to which the value of the input field is bound. The identifier can be used elsewhere (Line 9). The code to be executed for the l:onsubmit handler (Line 9) is not immediately executed but compiled to JavaScript for client-side execution. Curly braces indicate Links code embedded into XML. The l:onsubmit handler sends the current input value item to the server by calling echo. The item is returned by the server and appended to the list of received items using standard DOM APIs. The call to the server (Line 9) does not block the client. Instead, the continuation on the client is invoked when the result of the call is available. Client–server interaction is based on resumption passing style: Using continuation passing style transformation and defunctionalization, remote calls are implemented by passing the name of a function for the continuation and the data needed to continue the computation.

@multitier object Application {

@peer type Server <: { type Tie <: Single[Client] }

@peer type Client <: { type Tie <: Single[Server] }

val message = on[Client] { Event[String]() }

val echoMessage = on[Server] { message.asLocal }

def main() = on[Client] {

val items = echoMessage.asLocal.list

val list = Signal { ol(items() map { message => li(message) }) }

val inp = input.render

dom.document.body = body(

div(

inp,

button(onclick := { () => message.fire(inp.value) })("Echo!")),

list.asFrag).render

}

}

ScalaLoci is a language that targets generic distributed systems rather than the Web only, i.e., it is not restricted to a client–server architecture. To this end, ScalaLoci supports peer types to encode the different tiers at the type level. Placement types are used to assign locations to data and computations. ScalaLoci supports multitier reactives – language abstractions for reactive programming that are placed on specific locations – for composing data flows cross different peers.

The application first defines an input field (Line 11) using the ScalaTags library.{{Cite web|title=ScalaTags|url=https://com-lihaoyi.github.io/scalatags/|website=www.lihaoyi.com|access-date=2021-10-11}} The value of this field is used in the click event handler of a button (Line 15) to fire the message event with the current value of the input field. The value is then propagated to the server (Line 6) and back to the client (Line 9). On the client, the value of the event are accumulated using the list function and mapped to an HTML list (Line 10). This list is then used in the HTML (Line 16) to display the previous inputs.

• Hop/Hop.js{{Cite journal|last=Serrano|first=Manuel|date=2012|title=Multitier programming in Hop.|url=https://dblp.org/rec/journals/cacm/SerranoB12.html|journal=Commun. ACM|volume=55|issue=8|pages=53–59|doi=10.1145/2240236.2240253|s2cid=2152326|url-access=subscription}}{{Cite journal|last=Serrano|first=Manuel|date=2006|title=Hop: a language for programming the web 2.0.|url=https://dblp.org/rec/conf/oopsla/SerranoGL06.html|pages=975–985|doi=10.1145/1176617.1176756|s2cid=14306230|url-access=subscription}}{{Cite book|last=Serrano|first=Manuel|title=Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming |chapter=A glimpse of Hopjs |date=2016|url=https://dblp.org/rec/conf/icfp/SerranoP16.html|pages=180–192|doi=10.1145/2951913.2951916|isbn=9781450342193|s2cid=18393160 }}
• Links{{Cite book|last=Cooper|first=Ezra|title=Formal Methods for Components and Objects |chapter=Links: Web Programming Without Tiers |date=2006|series=Lecture Notes in Computer Science|volume=4709|url=https://dblp.org/rec/conf/fmco/CooperLWY06.html|pages=266–296|doi=10.1007/978-3-540-74792-5_12|hdl=20.500.11820/ef5f100a-0366-4b85-8ef1-622fd7fbb53a |isbn=978-3-540-74791-8|s2cid=16397220 }}{{Cite journal|last=Fowler|first=Simon|date=2019|title=Exceptional asynchronous session types: session types without tiers.|url=https://dblp.org/rec/journals/pacmpl/FowlerLMD19.html|journal=Proc. ACM Program. Lang.|volume=3|issue=POPL|pages=28:1–28:29|doi=10.1145/3290341|s2cid=57757469|doi-access=free|hdl=1808/27512|hdl-access=free}}
• Ur/Web{{Cite journal|last=Chlipala|first=Adam|date=2015|title=Ur/Web: A Simple Model for Programming the Web.|url=https://dblp.org/rec/conf/popl/Chlipala15.html|pages=153–165|doi=10.1145/2676726.2677004|s2cid=9440677|url-access=subscription}}
• Eliom/Ocsigen{{Cite journal|last=Balat|first=Vincent|date=2006|title=Ocsigen: typing web interaction with objective Caml.|url=https://dblp.org/rec/conf/ml/Balat06.html|pages=84–94|doi=10.1145/1159876.1159889|s2cid=6131454|url-access=subscription}}{{Cite book|last=Radanne|first=Gabriel|title=Companion of the Web Conference 2018 on the Web Conference 2018 - WWW '18 |chapter=Tierless Web Programming in the Large |date=2018|url=https://dblp.org/rec/conf/www/RadanneV18.html|pages=681–689|doi=10.1145/3184558.3185953|isbn=9781450356404|s2cid=3304415}}
• ScalaLoci{{Cite journal|last=Weisenburger|first=Pascal|date=2018|title=Distributed system development with ScalaLoci.|url=https://dblp.org/rec/journals/pacmpl/WeisenburgerKS18.html|journal=Proc. ACM Program. Lang.|volume=2|issue=OOPSLA|pages=129:1–129:30|doi=10.1145/3276499|s2cid=53090153|doi-access=free}}
• StiP.js{{Cite book|last=Philips|first=Laure|title=Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software |chapter=Towards Tierless Web Development without Tierless Languages |date=2014|url=https://dblp.org/rec/conf/oopsla/PhilipsRCM14.html|pages=69–81|doi=10.1145/2661136.2661146|isbn=9781450332101|s2cid=15774367}}{{Cite journal|last=Philips|first=Laure|date=2018|title=Search-based Tier Assignment for Optimising Offline Availability in Multi-tier Web Applications.|url=https://dblp.org/rec/journals/programming/PhilipsKMR18.html|journal=Programming Journal|volume=2|issue=2|pages=3|doi=10.22152/programming-journal.org/2018/2/3|s2cid=11256561|doi-access=free|arxiv=1712.01161}}
• Scala Multi-Tier FRP{{Cite book|last=Reynders|first=Bob|title=Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software |chapter=Multi-Tier Functional Reactive Programming for the Web |date=2014|url=https://dblp.org/rec/conf/oopsla/ReyndersDP14.html|pages=55–68|doi=10.1145/2661136.2661140|isbn=9781450332101|s2cid=16761616}}
• OpaRajchenbach-Teller, D., & Sinot, Franois-Régis. (2010). Opa: Language support for a sane, safe and secure web. Proceedings of the OWASP AppSec Research, 2010(1).
• AmbientTalk/R{{Cite book|last=Carreton|first=Andoni Lombide|title=Objects, Models, Components, Patterns |chapter=Loosely-Coupled Distributed Reactive Programming in Mobile Ad Hoc Networks |date=2010|series=Lecture Notes in Computer Science|volume=6141|url=https://dblp.org/rec/conf/tools/CarretonMCM10.html|pages=41–60|doi=10.1007/978-3-642-13953-6_3|isbn=978-3-642-13952-9}}{{Cite book|last=Dedecker|first=Jessie|date=2006|title=Ambient-Oriented Programming in AmbientTalk.|chapter=Ambient-Oriented Programming in Ambient Talk|series=Lecture Notes in Computer Science|volume=4067|chapter-url=https://dblp.org/rec/conf/ecoop/DedeckerCMDM06.html|pages=230–254|doi=10.1007/11785477_16|isbn=978-3-540-35726-1}}
• ML5{{Cite book|last=VII|first=Tom Murphy|title=Trustworthy Global Computing |chapter=Type-Safe Distributed Programming with ML5 |date=2007|series=Lecture Notes in Computer Science|volume=4912|url=https://dblp.org/rec/conf/tgc/VIICH07.html|pages=108–123|doi=10.1007/978-3-540-78663-4_9|isbn=978-3-540-78662-7|s2cid=12534714 }}
• WebSharper{{Cite book|last1=Bjornson|first1=Joel|last2=Tayanovskyy|first2=Anton|last3=Granicz|first3=Adam|title=Implementation and Application of Functional Languages |chapter=Composing Reactive GUIs in F# Using WebSharper |date=2010|series=Lecture Notes in Computer Science |volume=6647 |page=49|location=Berlin, Heidelberg|publisher=Springer-Verlag|doi=10.1007/978-3-642-24276-2_13|isbn=978-3-642-24275-5 }}
• Haste{{Cite journal|last1=Ekblad|first1=Anton|last2=Claessen|first2=Koen|date=2015-05-11|title=A seamless, client-centric programming model for type safe web applications|url=http://dx.doi.org/10.1145/2775050.2633367|journal=ACM SIGPLAN Notices|volume=49|issue=12|pages=79–89|doi=10.1145/2775050.2633367|issn=0362-1340|url-access=subscription}}
• Fun{{Cite web|title=Fun (a programming language for the realtime web)|url=http://marcuswest.in/essays/fun-intro/|website=marcuswest.in|access-date=2020-05-04}}
• Koka{{Cite journal|last=Leijen|first=Daan|date=2014|title=Koka: Programming with Row Polymorphic Effect Types.|journal=Electronic Proceedings in Theoretical Computer Science|volume=153|url=https://dblp.org/rec/journals/corr/Leijen14.html|pages=100–126|doi=10.4204/EPTCS.153.8|arxiv=1406.2061|s2cid=14902937}}
• Multi-Tier Calculus{{Cite book|last=Neubauer|first=Matthias|title=Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages |chapter=From sequential programs to multi-tier applications by program transformation |date=2005|url=https://dblp.org/rec/conf/popl/NeubauerT05.html|pages=221–232|doi=10.1145/1040305.1040324|isbn=158113830X|s2cid=10338936}}
• Swift{{Cite journal|last1=ChongStephen|last2=LiuJed|last3=C|first3=MyersAndrew|last4=QiXin|last5=VikramK|last6=ZhengLantian|last7=ZhengXin|date=2007-10-14|title=Secure web applications via automatic partitioning|url=https://dl.acm.org/doi/abs/10.1145/1323293.1294265|journal=ACM SIGOPS Operating Systems Review|volume=41|issue=6|pages=31–44|language=EN|doi=10.1145/1323293.1294265|hdl=1813/5769 |hdl-access=free}}
• Volta{{Cite journal|last=Manolescu|first=Dragos|date=2008|title=Volta: Developing Distributed Applications by Recompiling.|url=https://dblp.org/rec/journals/software/ManolescuBL08.html|journal=IEEE Software|volume=25|issue=5|pages=53–59|doi=10.1109/MS.2008.131|s2cid=24360031|url-access=subscription}}
• GWT{{Cite book|last=Kereki, Federico, 1960-|url=https://www.worldcat.org/oclc/606556208|title=Essential GWT: building for the web with Google Web toolkit 2|date=2011|publisher=Addison-Wesley|isbn=978-0-321-70563-1|location=Upper Saddle River, NJ|oclc=606556208}}
• Meteor{{Cite book|last=Strack, Isaac|url=https://www.worldcat.org/oclc/823718999|title=Getting started with Meteor JavaScript framework|date=January 2012|isbn=978-1-78216-083-0|location=Birmingham|oclc=823718999}}
• J-Orchestra{{Cite book|last=Tilevich|first=Eli|title=ECOOP 2002 — Object-Oriented Programming |chapter=J-Orchestra: Automatic Java Application Partitioning |date=2002|series=Lecture Notes in Computer Science|volume=2374|url=https://dblp.org/rec/conf/ecoop/TilevichS02.html|pages=178–204|doi=10.1007/3-540-47993-7_8|hdl=1853/6531 |isbn=978-3-540-43759-8}}
• Hiphop{{Cite book|last1=Berry|first1=Gérard|last2=Nicolas|first2=Cyprien|last3=Serrano|first3=Manuel|title=Proceedings of the 1st ACM SIGPLAN international workshop on Programming language and systems technologies for internet clients |chapter=Hiphop |date=2011|chapter-url=http://dx.doi.org/10.1145/2093328.2093337|page=49|location=New York, New York, USA|publisher=ACM Press|doi=10.1145/2093328.2093337|isbn=978-1-4503-1171-7|s2cid=1280230}}
• Distributed Orc{{Cite journal|last=Thywissen|first=John A.|date=2016|title=Implicitly Distributing Pervasively Concurrent Programs: Extended abstract.|url=https://dblp.org/rec/conf/ecoop/ThywissenPC16.html|pages=1|doi=10.1145/2957319.2957370|s2cid=6124391|url-access=subscription}}
• Jif/split{{Cite journal|last=Zdancewic|first=Steve|date=2002|title=Secure program partitioning.|url=https://dblp.org/rec/journals/tocs/ZdancewicZNM02.html|journal=ACM Trans. Comput. Syst.|volume=20|issue=3|pages=283–328|doi=10.1145/566340.566343|s2cid=1776939|url-access=subscription}}
• Fission{{Cite journal|last1=Guha|first1=Arjun|last2=Jeannin|first2=Jean-Baptiste|last3=Nigam|first3=Rachit|last4=Tangen|first4=Jane|last5=Shambaugh|first5=Rian|date=2017|editor-last=Lerner|editor-first=Benjamin S.|editor2-last=Bodík|editor2-first=Rastislav|editor3-last=Krishnamurthi|editor3-first=Shriram|title=Fission: Secure Dynamic Code-Splitting for JavaScript|url=http://drops.dagstuhl.de/opus/volltexte/2017/7124|journal=2nd Summit on Advances in Programming Languages (SNAPL 2017)|series=Leibniz International Proceedings in Informatics (LIPIcs)|location=Dagstuhl, Germany|publisher=Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik|volume=71|pages=5:1–5:13|doi=10.4230/LIPIcs.SNAPL.2017.5|doi-access=free |isbn=978-3-95977-032-3}}
• SIF{{Cite journal|last=Chong|first=Stephen|date=2007|title=SIF: Enforcing Confidentiality and Integrity in Web Applications.|url=https://www.usenix.org/conference/16th-usenix-security-symposium/sif-enforcing-confidentiality-and-integrity-web}}
• WebDSL{{Cite journal|last=Groenewegen|first=Danny M.|date=2008|title=WebDSL: a domain-specific language for dynamic web applications.|url=https://dblp.org/rec/conf/oopsla/GroenewegenHKV08.html|pages=779–780|doi=10.1145/1449814.1449858|s2cid=8073129|url-access=subscription}}
• Acute{{Cite journal|last=Sewell|first=Peter|date=2005|title=Acute: high-level programming language design for distributed computation.|url=https://dblp.org/rec/conf/icfp/SewellLWNAHV05.html|pages=15–26|doi=10.1145/1086365.1086370|s2cid=1308126|url-access=subscription}}
• Mobl{{Cite book|last=Hemel|first=Zef|title=Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications |chapter=Declaratively programming the mobile web with Mobl |date=2011|url=https://dblp.org/rec/conf/oopsla/HemelV11.html|pages=695–712|doi=10.1145/2048066.2048121|isbn=9781450309400|s2cid=10480906}}
• High-Level Abstractions for Web Programming{{Cite book|last=Richard-Foy|first=Julien|title=Proceedings of the 12th international conference on Generative programming: Concepts & experiences |chapter=Efficient high-level abstractions for web programming |date=2013|url=https://dblp.org/rec/conf/gpce/Richard-FoyBJ13.html|pages=53–60|doi=10.1145/2517208.2517227|isbn=9781450323734|s2cid=14305623}}

{{reflist}}

{{Programming paradigms navbox}}

Category:Programming paradigms