title = {Separating Use and Reuse to Improve Both},
  author = {Arora, Hrshikesh and Servetto, Marco and Oliveira, Bruno CDS},
  journal = {arXiv preprint arXiv:1902.00546},
  year = {2019}
  author = {Meyer, B.},
  title = {Object-oriented Software Construction},
  publisher = {Prentice Hall International},
  year = {1997},
  volume = {3}
  author = {{Wikipedia contributors}},
  title = {Covariance and contravariance (computer science) --- {Wikipedia}{,} The Free Encyclopedia},
  year = {2019},
  howpublished = {\url{}},
  note = {[Online; accessed 9-April-2019]}
  author = {Castagna, Giuseppe},
  title = {Covariance and Contravariance: Conflict Without a Cause},
  journal = {ACM Trans. Program. Lang. Syst.},
  issue_date = {May 1995},
  volume = {17},
  number = {3},
  month = may,
  year = {1995},
  issn = {0164-0925},
  pages = {431--447},
  numpages = {17},
  url = {},
  doi = {10.1145/203095.203096},
  acmid = {203096},
  publisher = {ACM},
  address = {New York, NY, USA},
  keywords = {object-oriented languages, type theory}
  title = {Semantics-driven language design:: Statically type-safe virtual types in object-oriented languages},
  author = {Bruce, Kim B and Vanderwaart, Joseph C},
  journal = {Electronic Notes in Theoretical Computer Science},
  volume = {20},
  pages = {50--75},
  year = {1999},
  publisher = {Elsevier}
  title = {Some challenging typing issues in object-oriented languages},
  author = {Bruce, Kim B},
  journal = {Electronic Notes in Theoretical Computer Science},
  volume = {82},
  number = {8},
  pages = {1--29},
  year = {2003},
  publisher = {Elsevier}
  author = {{Wikipedia contributors}},
  title = {Separation of concerns --- {Wikipedia}{,} The Free Encyclopedia},
  year = {2019},
  url = {},
  note = {[Online; accessed 11-April-2019]}
  title = {Purely functional implementation of attribute grammars},
  author = {Saraiva, Joao and Swierstra, SD},
  year = {1999},
  publisher = {Universiteit Utrecht}
  title = {Refinement Types ML},
  author = {Freeman, Tim},
  year = {1994},
  title = {Resource {Polymorphism}},
  url = {},
  abstract = {We present a resource-management model for ML-style programming languages, designed to be compatible with the OCaml philosophy and runtime model. This is a proposal to extend the OCaml language with destructors, move semantics, and resource polymorphism, to improve its safety, efficiency, interoperability, and expressiveness. It builds on the ownership-and-borrowing models of systems programming languages (Cyclone, C++11, Rust) and on linear types in functional programming (Linear Lisp, Clean, Alms). It continues a synthesis of resources from systems programming and resources in linear logic initiated by Baker. It is a combination of many known and some new ideas. On the novel side, it highlights the good mathematical structure of Stroustrup's "Resource acquisition is initialisation" (RAII) idiom for resource management based on destructors, a notion sometimes confused with finalizers, and builds on it a notion of resource polymorphism, inspired by polarisation in proof theory, that mixes C++'s RAII and a tracing garbage collector (GC). The proposal targets a new spot in the design space, with an automatic and predictable resource-management model, at the same time based on lightweight and expressive language abstractions. It is backwards-compatible: current code is expected to run with the same performance, the new abstractions fully combine with the current ones, and it supports a resource-polymorphic extension of libraries. It does so with only a few additions to the runtime, and it integrates with the current GC implementation. It is also compatible with the upcoming multicore extension, and suggests that the Rust model for eliminating data-races applies. Interesting questions arise for a safe and practical type system, many of which have already been thoroughly investigated in the languages and prototypes Cyclone, Rust, and Alms.},
  language = {en},
  urldate = {2019-04-13},
  journal = {arXiv:1803.02796 [cs]},
  author = {Munch-Maccagnoni, Guillaume},
  month = mar,
  year = {2018},
  note = {arXiv: 1803.02796},
  keywords = {Computer Science - Logic in Computer Science, Computer Science - Programming Languages},
  file = {Munch-Maccagnoni - 2018 - Resource Polymorphism.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/YM3T8EZQ/Munch-Maccagnoni - 2018 - Resource Polymorphism.pdf:application/pdf}
  title = {Familia: unifying interfaces, type classes, and family polymorphism},
  volume = {1},
  issn = {24751421},
  shorttitle = {Familia},
  url = {},
  doi = {10.1145/3133894},
  language = {en},
  number = {OOPSLA},
  urldate = {2019-04-17},
  journal = {Proceedings of the ACM on Programming Languages},
  author = {Zhang, Yizhou and Myers, Andrew C.},
  month = oct,
  year = {2017},
  keywords = {pld},
  pages = {1--31},
  file = {Zhang e Myers - 2017 - Familia unifying interfaces, type classes, and fa.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/XKLFUEER/Zhang e Myers - 2017 - Familia unifying interfaces, type classes, and fa.pdf:application/pdf}
  title = {Making reliable distributed systems in the presence of sodware errors},
  language = {en},
  author = {Armstrong, Joe},
  pages = {297},
  file = {Armstrong - Making reliable distributed systems in the presenc.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/DCJNRRFE/Armstrong - Making reliable distributed systems in the presenc.pdf:application/pdf}
  title = {The {Split}-{Apply}-{Combine} {Strategy} for {Data} {Analysis}},
  volume = {40},
  issn = {1548-7660},
  url = {},
  doi = {10.18637/jss.v040.i01},
  abstract = {Many data analysis problems involve the application of a split-apply-combine strategy, where you break up a big problem into manageable pieces, operate on each piece independently and then put all the pieces back together. This insight gives rise to a new R package that allows you to smoothly apply this strategy, without having to worry about the type of structure in which your data is stored.},
  language = {en},
  number = {1},
  urldate = {2019-04-13},
  journal = {Journal of Statistical Software},
  author = {Wickham, Hadley},
  year = {2011},
  keywords = {pld, design-patterns},
  file = {Wickham - 2011 - The Split-Apply-Combine Strategy for Data Analysis.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/2Q6AP2VJ/Wickham - 2011 - The Split-Apply-Combine Strategy for Data Analysis.pdf:application/pdf}
  title = {{MapReduce}: simplified data processing on large clusters},
  volume = {51},
  issn = {00010782},
  shorttitle = {{MapReduce}},
  url = {},
  doi = {10.1145/1327452.1327492},
  abstract = {MapReduce is a programming model and an associated implementation for processing and generating large data sets. Users specify a map function that processes a key/value pair to generate a set of intermediate key/value pairs, and a reduce function that merges all intermediate values associated with the same intermediate key. Many real world tasks are expressible in this model, as shown in the paper.},
  language = {en},
  number = {1},
  urldate = {2019-05-31},
  journal = {Communications of the ACM},
  author = {Dean, Jeffrey and Ghemawat, Sanjay},
  month = jan,
  year = {2008},
  pages = {107},
  file = {Dean e Ghemawat - 2008 - MapReduce simplified data processing on large clu.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/296W2WAK/Dean e Ghemawat - 2008 - MapReduce simplified data processing on large clu.pdf:application/pdf}
  author = {{Wikipedia contributors}},
  title = {Ontology (information science) --- {Wikipedia}{,} The Free Encyclopedia},
  year = {2019},
  url = {},
  note = {[Online; accessed 3-June-2019]}
  title = {OWL 2 web ontology language primer},
  author = {Hitzler, Pascal and Kr{\"o}tzsch, Markus and Parsia, Bijan and Patel-Schneider, Peter F and Rudolph, Sebastian},
  journal = {W3C recommendation},
  volume = {27},
  number = {1},
  pages = {123},
  year = {2009},
  publisher = {World Wide Web Consortium (W3C)}
  author = {{Wikipedia contributors}},
  title = {Dependency injection --- {Wikipedia}{,} The Free Encyclopedia},
  year = {2019},
  url = {},
  note = {[Online; accessed 5-June-2019]}
  address = {Berlin, Heidelberg},
  title = {Why {Do} {Scala} {Developers} {Mix} the {Actor} {Model} with other {Concurrency} {Models}?},
  volume = {7920},
  isbn = {978-3-642-39037-1 978-3-642-39038-8},
  url = {},
  abstract = {Mixing the actor model with other concurrency models in a single program can break the actor abstraction. This increases the chance of creating deadlocks and data races—two mistakes that are hard to make with actors. Furthermore, it prevents the use of many advanced testing, modeling, and verification tools for actors, as these require pure actor programs. This study is the first to point out the phenomenon of mixing concurrency models and to systematically identify the factors leading to it. We studied 15 large, mature, and actively maintained actor programs written in Scala and found that 80\% of them mix the actor model with another concurrency model. Consequently, a large part of real-world actor programs does not use actors to their fullest advantage. Inspection of the programs and discussion with the developers reveal two reasons for mixing that can be influenced by researchers and library-builders: weaknesses in the actor library implementations, and shortcomings of the actor model itself.},
  language = {en},
  urldate = {2019-04-25},
  booktitle = {{ECOOP} 2013 – {Object}-{Oriented} {Programming}},
  publisher = {Springer Berlin Heidelberg},
  author = {Tasharofi, Samira and Dinges, Peter and Johnson, Ralph E.},
  editor = {Hutchison, David and Kanade, Takeo and Kittler, Josef and Kleinberg, Jon M. and Mattern, Friedemann and Mitchell, John C. and Naor, Moni and Nierstrasz, Oscar and Pandu Rangan, C. and Steffen, Bernhard and Sudan, Madhu and Terzopoulos, Demetri and Tygar, Doug and Vardi, Moshe Y. and Weikum, Gerhard and Castagna, Giuseppe},
  year = {2013},
  doi = {10.1007/978-3-642-39038-8_13},
  keywords = {concurrency, Unterstützungssystem (Informatik)},
  pages = {302--326},
  file = {Tasharofi et al. - 2013 - Why Do Scala Developers Mix the Actor Model with o.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/V59VHWKP/Tasharofi et al. - 2013 - Why Do Scala Developers Mix the Actor Model with o.pdf:application/pdf}
  title = {Consistency {Analysis} in {Bloom}: a {CALM} and {Collected} {Approach}},
  abstract = {Distributed programming has become a topic of widespread interest, and many programmers now wrestle with tradeoffs between data consistency, availability and latency. Distributed transactions are often rejected as an undesirable tradeoff today, but in the absence of transactions there are few concrete principles or tools to help programmers design and verify the correctness of their applications. We address this situation with the CALM principle, which connects the idea of distributed consistency to program tests for logical monotonicity. We then introduce Bloom, a distributed programming language that is amenable to high-level consistency analysis and encourages order-insensitive programming. We present a prototype implementation of Bloom as a domain-specific language in Ruby. We also propose a program analysis technique that identifies points of order in Bloom programs: code locations where programmers may need to inject coordination logic to ensure consistency. We illustrate these ideas with two case studies: a simple key-value store and a distributed shopping cart service.},
  language = {en},
  author = {Alvaro, Peter and Conway, Neil and Hellerstein, Joseph M and Marczak, William R},
  keywords = {concurrency, dbms},
  pages = {12},
  file = {Alvaro et al. - Consistency Analysis in Bloom a CALM and Collecte.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/7DGKYWCX/Alvaro et al. - Consistency Analysis in Bloom a CALM and Collecte.pdf:application/pdf}
  title = {Anna: {A} {KVS} {For} {Any} {Scale}},
  abstract = {Modern cloud providers offer dense hardware with multiple cores and large memories, hosted in global platforms. This raises the challenge of implementing high-performance software systems that can effectively scale from a single core to multicore to the globe. Conventional wisdom says that software designed for one scale point needs to be rewritten when scaling up by 10−100× [1]. In contrast, we explore how a system can be architected to scale across many orders of magnitude by design. We explore this challenge in the context of a new keyvalue store system called Anna: a partitioned, multi-mastered system that achieves high performance and elasticity via waitfree execution and coordination-free consistency. Our design rests on a simple architecture of coordination-free actors that perform state update via merge of lattice-based composite data structures. We demonstrate that a wide variety of consistency models can be elegantly implemented in this architecture with unprecedented consistency, smooth fine-grained elasticity, and performance that far exceeds the state of the art.},
  language = {en},
  author = {Wu, Chenggang and Faleiro, Jose M and Lin, Yihan and Hellerstein, Joseph M},
  keywords = {concurrency, dbms},
  pages = {12},
  file = {Wu et al. - Anna A KVS For Any Scale.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/PXYX2VFA/Wu et al. - Anna A KVS For Any Scale.pdf:application/pdf}
  title = {Laws for communicating parallel processes},
  url = {},
  abstract = {Baker},
  urldate = {2019-06-30},
  journal = {MIT Artificial Intelligence Laboratory},
  author = {Hewitt},
  year = {1977},
  keywords = {concurrency, distributed},
  file = {Hewitt - 1977 - Laws for communicating parallel processes.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/WHWYZTWX/Hewitt - 1977 - Laws for communicating parallel processes.pdf:application/pdf}
  added-at = {2010-06-05T16:40:25.000+0200},
  asin = {0201633612},
  author = {Gamma, Erich and Helm, Richard and Johnson, Ralph and Vlissides, John M.},
  biburl = {},
  description = { Design Patterns: Elements of Reusable Object-Oriented Software (9780201633610): Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides: Books},
  dewey = {005.12},
  ean = {9780201633610},
  edition = 1,
  interhash = {7fe32957be97afaf4ecb38b5490d23b4},
  intrahash = {7e3f1154ab1fbce54752a46dba7f2217},
  isbn = {0201633612},
  keywords = {DBIS Design Object-Oriented Patterns SS2010 Seminar Software},
  publisher = {Addison-Wesley Professional},
  timestamp = {2010-06-05T16:40:25.000+0200},
  title = {Design Patterns: Elements of Reusable Object-Oriented Software},
  url = {},
  year = 1994
  address = {Berlin, Heidelberg},
  title = {Failboxes: {Provably} {Safe} {Exception} {Handling}},
  volume = {5653},
  isbn = {978-3-642-03012-3 978-3-642-03013-0},
  shorttitle = {Failboxes},
  url = {},
  abstract = {The primary goal of exception mechanisms is to help ensure that when an operation fails, code that depends on the operation’s successful completion is not executed (a property we call dependency safety). However, the exception mechanisms of current mainstream programming languages make it hard to achieve dependency safety, in particular when objects manipulated inside a try block outlive the try block.},
  language = {en},
  urldate = {2019-04-25},
  booktitle = {{ECOOP} 2009 – {Object}-{Oriented} {Programming}},
  publisher = {Springer Berlin Heidelberg},
  author = {Jacobs, Bart and Piessens, Frank},
  editor = {Drossopoulou, Sophia},
  year = {2009},
  doi = {10.1007/978-3-642-03013-0_22},
  keywords = {concurrency, exceptions},
  pages = {470--494},
  file = {Jacobs e Piessens - 2009 - Failboxes Provably Safe Exception Handling.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/VS4QMG48/Jacobs e Piessens - 2009 - Failboxes Provably Safe Exception Handling.pdf:application/pdf}
  title = {Strong exception-safety for checked and unchecked exceptions.},
  volume = {10},
  issn = {1660-1769},
  url = {},
  doi = {10.5381/jot.2011.10.1.a1},
  abstract = {Exception-safety strong guarantee: The operation has either completed successfully or thrown an exception, leaving the program state exactly as it was before the operation started.” David Abrahams [Abr00] The above definition of strong exception-safety comes from the world of C++, but it can be applied to any language. Because the exception-safety strong guarantee plays a central role in easing the development of robust software, we have designed a type-system able to capture its essence. The idea is that the state of the reachable objects at the beginning of a catch block is the same as the beginning of the corresponding try block.},
  language = {en},
  urldate = {2019-04-25},
  journal = {The Journal of Object Technology},
  author = {Lagorio, Giovanni and Servetto, Marco},
  year = {2011},
  pages = {1:1},
  file = {Lagorio e Servetto - 2011 - Strong exception-safety for checked and unchecked .pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/GG925NIJ/Lagorio e Servetto - 2011 - Strong exception-safety for checked and unchecked .pdf:application/pdf}
  title = {Implementing {Retry} - {Featuring} {AOP}},
  isbn = {978-1-4244-4678-0},
  url = {},
  doi = {10.1109/LADC.2009.15},
  abstract = {Everyday experience tells us that some errors are transient, but also that some can be handled simply by “retrying” the failed operation. For instance, a glitch on the network might turn a resource unreachable for a short period of time; or a sudden peak of work on a server can cause a momentary denial of service. In many occasions, without other kind of specialized recovery code, it is possible to keep a program running only by retrying a failed operation. Unfortunately, retry is not explicitly available on many platforms or programming languages and, even if it were, it could not be blindly used for dealing with every abnormal situation. On languages like C\# or Java, or even on languages that offer the retry construct such as Smalltalk and Eiffel, where errors are represented and communicated through exceptions, there is no simple way to clear the effects of a failed operation and, thus, re-attempt its execution. Programmers have to explicitly write sometimes complex and error-prone code to repair the state of a program and the execution context. In this paper, we propose an AOP technique for implementing “retry” on systems lacking such a feature without using any language extensions for AOP or imposing modifications to the development language. Our approach eliminates the need for programmers to write “state-cleaning” code for normal objects by means of a transparent transactional mechanism and provides the means to identify non-idempotent operations on the code. In our evaluation we show that a relevant number of application failures can be masked using this approach.},
  language = {en},
  urldate = {2019-06-24},
  publisher = {IEEE},
  author = {Cabral, Bruno and Marques, Paulo},
  month = sep,
  year = {2009},
  pages = {73--80},
  file = {Cabral e Marques - 2009 - Implementing Retry - Featuring AOP.pdf:/home/zanibonim/lavoro/dokmelody/Zotero/storage/5GJ7UIPV/Cabral e Marques - 2009 - Implementing Retry - Featuring AOP.pdf:application/pdf}

This file was generated by bibtex2html 1.99.