English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Tools annual

Global: Zendy Free Plan

Global: Zendy Tools monthly

Global: Zendy Plus monthly

Multitier programming languages reduce the complexity of developingdistributed systems by developing the distributed system in a single coherentcode base. The compiler or the runtime separate the code for the components ofthe distributed system, enabling abstraction over low level implementationdetails such as data representation, serialization and network protocols. OurScalaLoci language allows developers to declare the different components andtheir architectural relation at the type level, allowing static reasoning aboutabout distribution and remote communication and guaranteeing static type safetyacross components. The compiler splits the multitier program into thecomponent-specific code and automatically generates the communicationboilerplate. Communication between components can be modeled by declarativelyspecifying data flows between components using reactive programming.  In this paper, we report on the implementation of our design and ourexperience with embedding our language features into Scala as a host language.We show how a combination of Scala's advanced type level programming and itsmacro system can be used to enrich the language with new abstractions. Wecomment on the challenges we encountered and the solutions we developed for ourcurrent implementation and outline suggestions for an improved macro system tosupport the such use cases of embedding of domain-specific abstractions.

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala