Implicit concurrency between handlers is important for event driven systems because it helps simultaneously promote modularity and scalability. Knowing the side-effect of the handlers is critical in these systems to avoid concurrency hazards such as data races. As event systems are dynamic because statically known and unknown handlers can register at almost any time during program execution, static effect analyses must reconcile over competing goals such as precision, soundness and modularity. We recently developed asynchronous, typed events, a system that can analyze the effects of the handlers at runtime. This mechanism utilizes runtime information to enable precise effect computation and greatly improves concurrency between handlers. In this paper, we present the formal underpinnings of asynchronous, typed events, and examine the concurrency safety properties it provides. The technical innovations of our system include a novel effect system to soundly approximate the dynamism introduced by runtime handlers registration, a static analysis to precompute the effects and a dynamic analysis that uses the precomputed effects to improve concurrency. Our design simplifies modular concurrency reasoning and avoids concurrency hazards.
{"title":"A type-and-effect system for asynchronous, typed events","authors":"Yuheng Long, Hridesh Rajan","doi":"10.1145/2889443.2889446","DOIUrl":"https://doi.org/10.1145/2889443.2889446","url":null,"abstract":"Implicit concurrency between handlers is important for event driven systems because it helps simultaneously promote modularity and scalability. Knowing the side-effect of the handlers is critical in these systems to avoid concurrency hazards such as data races. As event systems are dynamic because statically known and unknown handlers can register at almost any time during program execution, static effect analyses must reconcile over competing goals such as precision, soundness and modularity. We recently developed asynchronous, typed events, a system that can analyze the effects of the handlers at runtime. This mechanism utilizes runtime information to enable precise effect computation and greatly improves concurrency between handlers. In this paper, we present the formal underpinnings of asynchronous, typed events, and examine the concurrency safety properties it provides. The technical innovations of our system include a novel effect system to soundly approximate the dynamism introduced by runtime handlers registration, a static analysis to precompute the effects and a dynamic analysis that uses the precomputed effects to improve concurrency. Our design simplifies modular concurrency reasoning and avoids concurrency hazards.","PeriodicalId":225551,"journal":{"name":"Proceedings of the 15th International Conference on Modularity","volume":"26 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-03-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126656474","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Event-driven programming has become a major paradigm in developing concurrent, distributed systems. Its benefits are often informally captured by the key tenet of “decoupling”, a notion which roughly captures the ability of modules to join and leave (or fail) applications dynamically, and to be developed by independent parties. Programming models for event-driven programming either make it hard to reason about global control flow, thus hampering sound execution, or sacrifice decoupling to aid in reasoning about control flow. This work fills the gap by introducing a programming model – dubbed cooperative decoupled processes – that achieves both decoupling and reasoning about global control flow. We introduce this programming model through an event calculus, loosely inspired by the Join calculus, that enables reasoning about cooperative decoupled processes through the concepts of pre- and postconditions. A linear type system controls aliasing of events to ensure uniqueness of control flow and thus safe exchange of shared events. Fundamental properties of the type system such as subject reduction, migration safety, and progress are established.
{"title":"Cooperative decoupled processes: the e-calculus and linearity","authors":"Andi Bejleri, M. Mezini, P. Eugster","doi":"10.1145/2889443.2889449","DOIUrl":"https://doi.org/10.1145/2889443.2889449","url":null,"abstract":"Event-driven programming has become a major paradigm in developing concurrent, distributed systems. Its benefits are often informally captured by the key tenet of “decoupling”, a notion which roughly captures the ability of modules to join and leave (or fail) applications dynamically, and to be developed by independent parties. Programming models for event-driven programming either make it hard to reason about global control flow, thus hampering sound execution, or sacrifice decoupling to aid in reasoning about control flow. This work fills the gap by introducing a programming model – dubbed cooperative decoupled processes – that achieves both decoupling and reasoning about global control flow. We introduce this programming model through an event calculus, loosely inspired by the Join calculus, that enables reasoning about cooperative decoupled processes through the concepts of pre- and postconditions. A linear type system controls aliasing of events to ensure uniqueness of control flow and thus safe exchange of shared events. Fundamental properties of the type system such as subject reduction, migration safety, and progress are established.","PeriodicalId":225551,"journal":{"name":"Proceedings of the 15th International Conference on Modularity","volume":"208 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-03-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116424047","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
M. Oliveira, R. Bonifácio, G. N. Ramos, Márcio Ribeiro
Product flexibility is one of the expected benefits of a modular design, and thus "it should be possible to make drastic changes to a module without changing others." Accordingly, the data available on version control systems might help software architects to reason about some quality attributes of the modular decomposition of a system. In this paper we investigate the impact of co-change dependencies into system stability, that is, the potential ripple effect that might occur during maintenance tasks. Here we use (a) Design Structure Matrices (DSMs) for visualizing dependencies motivated by assets’ co-change and (b) two metrics for estimating system stability: Propagation Cost of Changes and Clustered Cost of a Decomposition. We conducted a comprehensive study about co-change dependencies and their effects on system stability, considering the change history of six open-source Java systems: Derby, Eclipse UI, Eclipse JDT, Hadoop, Geronimo, and Lucene; and one relevant financial systems of the Brazilian Government (SIOP). We evaluated two distinct situations: first considering only the static dependencies of each system and then considering both static and co-change dependencies of each system. There is a significant impact of the co-change dependencies on the stability measurements for Derby, Hadoop, Lucene, and SIOP. This result suggests that the modular decomposition of these systems does not resemble their change history. Accordingly, our findings provide empirical evidence that the common approach for reasoning about the modular decomposition, which often uses only static dependencies, hides important details about the costs of maintenance tasks.
{"title":"Unveiling and reasoning about co-change dependencies","authors":"M. Oliveira, R. Bonifácio, G. N. Ramos, Márcio Ribeiro","doi":"10.1145/2889443.2889450","DOIUrl":"https://doi.org/10.1145/2889443.2889450","url":null,"abstract":"Product flexibility is one of the expected benefits of a modular design, and thus \"it should be possible to make drastic changes to a module without changing others.\" Accordingly, the data available on version control systems might help software architects to reason about some quality attributes of the modular decomposition of a system. In this paper we investigate the impact of co-change dependencies into system stability, that is, the potential ripple effect that might occur during maintenance tasks. Here we use (a) Design Structure Matrices (DSMs) for visualizing dependencies motivated by assets’ co-change and (b) two metrics for estimating system stability: Propagation Cost of Changes and Clustered Cost of a Decomposition. We conducted a comprehensive study about co-change dependencies and their effects on system stability, considering the change history of six open-source Java systems: Derby, Eclipse UI, Eclipse JDT, Hadoop, Geronimo, and Lucene; and one relevant financial systems of the Brazilian Government (SIOP). We evaluated two distinct situations: first considering only the static dependencies of each system and then considering both static and co-change dependencies of each system. There is a significant impact of the co-change dependencies on the stability measurements for Derby, Hadoop, Lucene, and SIOP. This result suggests that the modular decomposition of these systems does not resemble their change history. Accordingly, our findings provide empirical evidence that the common approach for reasoning about the modular decomposition, which often uses only static dependencies, hides important details about the costs of maintenance tasks.","PeriodicalId":225551,"journal":{"name":"Proceedings of the 15th International Conference on Modularity","volume":"48 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-03-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127782876","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Oliver Bracevac, Sebastian Erdweg, G. Salvaneschi, M. Mezini
Running distributed applications in the cloud involves deployment. That is, distribution and configuration of application services and middleware infrastructure. The considerable complexity of these tasks resulted in the emergence of declarative JSON-based domain-specific deployment languages to develop deployment programs. However, existing deployment programs unsafely compose artifacts written in different languages, leading to bugs that are hard to detect before run time. Furthermore, deployment languages do not provide extension points for custom implementations of existing cloud services such as application-specific load balancing policies. To address these shortcomings, we propose CPL (Cloud Platform Language), a statically-typed core language for programming both distributed applications as well as their deployment on a cloud platform. In CPL, application services and deployment programs interact through statically typed, extensible interfaces, and an application can trigger further deployment at run time. We provide a formal semantics of CPL and demonstrate that it enables type-safe, composable and extensible libraries of service combinators, such as load balancing and fault tolerance.
{"title":"CPL: a core language for cloud computing","authors":"Oliver Bracevac, Sebastian Erdweg, G. Salvaneschi, M. Mezini","doi":"10.1145/2889443.2889452","DOIUrl":"https://doi.org/10.1145/2889443.2889452","url":null,"abstract":"Running distributed applications in the cloud involves deployment. That is, distribution and configuration of application services and middleware infrastructure. The considerable complexity of these tasks resulted in the emergence of declarative JSON-based domain-specific deployment languages to develop deployment programs. However, existing deployment programs unsafely compose artifacts written in different languages, leading to bugs that are hard to detect before run time. Furthermore, deployment languages do not provide extension points for custom implementations of existing cloud services such as application-specific load balancing policies. To address these shortcomings, we propose CPL (Cloud Platform Language), a statically-typed core language for programming both distributed applications as well as their deployment on a cloud platform. In CPL, application services and deployment programs interact through statically typed, extensible interfaces, and an application can trigger further deployment at run time. We provide a formal semantics of CPL and demonstrate that it enables type-safe, composable and extensible libraries of service combinators, such as load balancing and fault tolerance.","PeriodicalId":225551,"journal":{"name":"Proceedings of the 15th International Conference on Modularity","volume":"5 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-02-02","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122185311","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
A. Peternier, Walter Binder, Erik Ernst, R. Hirschfeld
These are the proceedings of the 13th International Conference on Modularity (Modularity'14, formerly AOSD) in Lugano, Switzerland. This year's conference continues the tradition of being the premier international conference on modularity in software systems. Modularity'14 addresses all aspects of modularity, abstraction, and separation of concerns as they pertain to software, including new forms, uses, and analysis of modularity, along with the costs and benefits, and tradeoffs involved in their application. The broadening in scope of the conference is also reflected in the change of its name: the International Conference on Aspect-Oriented Software Development (AOSD) has evolved to become the International Conference on Modularity. Modularity provides the international computer science research community and its many subdisciplines (including software engineering, languages, and computer systems) with unique opportunities to come together to share and discuss perspectives, results, and visions with others mninterested in modularity as well as in the languages, development methods, architectures, algorithms, and other technologies organized around this fundamental concept. Modularity'14 comprises two main parts: Research Results and Modularity Visions. Both parts invited full, scholarly papers of the highest quality on results and new ideas in areas that include but are not limited to complex systems, software design and engineering, programming languages, cyber-physical systems, and other areas across the whole system life cycle. Research Results invited papers on new ideas and results, stressing the contribution of significant new research with rigorous and substantial validation of its technical claims, based on scientifically sound reflections on experience, analysis, experimentation, or formal models, and emphasizing compelling new ideas. The review process consisted of two rounds, as a further development of the multi-round model that has been used for four years at this conference. The outcome in the first round could be 'accept' and 'reject' as usual, but also 'reject, with a recommendation to resubmit'. The intention behind the third outcome is to push for improvements to papers that are promising, but not quite ready; and letting the same reviewers judge the improved paper. The multi-phase model is being used by multiple conferences in its own right, but it could also be considered to be a highly extended version of the well-known concept of an author response period. It is definitely our experience that this mechanism produces significant improvements in several papers, and we are very happy about the high quality of the selected papers. The Program Committee (PC) meetings were online meetings, heavily supported by online discussions in smaller groups. Submissions where one or more of the authors were members of the PC were reviewed and decided by the External Review Committee (ERC) before the PC meetings, such that the PC wa
{"title":"Proceedings of the 15th International Conference on Modularity","authors":"A. Peternier, Walter Binder, Erik Ernst, R. Hirschfeld","doi":"10.1145/2889443","DOIUrl":"https://doi.org/10.1145/2889443","url":null,"abstract":"These are the proceedings of the 13th International Conference on Modularity (Modularity'14, formerly AOSD) in Lugano, Switzerland. This year's conference continues the tradition of being the premier international conference on modularity in software systems. \u0000 \u0000Modularity'14 addresses all aspects of modularity, abstraction, and separation of concerns as they pertain to software, including new forms, uses, and analysis of modularity, along with the costs and benefits, and tradeoffs involved in their application. The broadening in scope of the conference is also reflected in the change of its name: the International Conference on Aspect-Oriented Software Development (AOSD) has evolved to become the International Conference on Modularity. Modularity provides the international computer science research community and its many subdisciplines (including software engineering, languages, and computer systems) with unique opportunities to come together to share and discuss perspectives, results, and visions with others mninterested in modularity as well as in the languages, development methods, architectures, algorithms, and other technologies organized around this fundamental concept. \u0000 \u0000Modularity'14 comprises two main parts: Research Results and Modularity Visions. Both parts invited full, scholarly papers of the highest quality on results and new ideas in areas that include but are not limited to complex systems, software design and engineering, programming languages, cyber-physical systems, and other areas across the whole system life cycle. \u0000 \u0000Research Results invited papers on new ideas and results, stressing the contribution of significant new research with rigorous and substantial validation of its technical claims, based on scientifically sound reflections on experience, analysis, experimentation, or formal models, and emphasizing compelling new ideas. The review process consisted of two rounds, as a further development of the multi-round model that has been used for four years at this conference. The outcome in the first round could be 'accept' and 'reject' as usual, but also 'reject, with a recommendation to resubmit'. The intention behind the third outcome is to push for improvements to papers that are promising, but not quite ready; and letting the same reviewers judge the improved paper. The multi-phase model is being used by multiple conferences in its own right, but it could also be considered to be a highly extended version of the well-known concept of an author response period. It is definitely our experience that this mechanism produces significant improvements in several papers, and we are very happy about the high quality of the selected papers. The Program Committee (PC) meetings were online meetings, heavily supported by online discussions in smaller groups. Submissions where one or more of the authors were members of the PC were reviewed and decided by the External Review Committee (ERC) before the PC meetings, such that the PC wa","PeriodicalId":225551,"journal":{"name":"Proceedings of the 15th International Conference on Modularity","volume":"101 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2014-04-22","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122618421","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：