International Conference on Modularity最新文献

{"title":"Graal and truffle: modularity and separation of concerns as cornerstones for building a multipurpose runtime","authors":"Thomas Würthinger","doi":"10.1145/2584469.2584663","DOIUrl":"https://doi.org/10.1145/2584469.2584663","url":null,"abstract":"Multi-language runtimes providing simultaneously high performance for several programming languages still remain an illusion. Industrial-strength managed language runtimes are built with a focus on one language (e.g., Java or C#). Other languages may compile to the bytecode formats of those managed language runtimes. However, the performance characteristics of the bytecode generation approach are often lagging behind compared to language runtimes specialized for a specific language. The performance of JavaScript is for example still orders of magnitude better on specialized runtimes (e.g., V8 or SpiderMonkey).\u0000 We present a solution to this problem by providing guest languages with a new way of interfacing with the host runtime. The semantics of the guest language is communicated to the host runtime not via generating bytecodes, but via an interpreter written in the host language. This gives guest languages a simple way to express the semantics of their operations including language-specific mechanisms for collecting profiling feedback. The efficient machine code is derived from the interpreter via automatic partial evaluation. The main components reused from the underlying runtime are the compiler and the garbage collector. They are both agnostic to the executed guest languages.\u0000 The host compiler derives the optimized machine code for hot parts of the guest language application via partial evaluation of the guest language interpreter. The interpreter definition can guide the host compiler to generate deoptimization points, i.e., exits from the compiled code. This allows guest language operations to use speculations: An operation could for example speculate that the type of an incoming parameter is constant. Furthermore, the guest language interpreter can use global assumptions about the system state that are registered with the compiled code. Finally, part of the interpreter's code can be excluded from the partial evaluation and remain shared across the system. This is useful for avoiding code explosion and appropriate for infrequently executed paths of an operation. These basic mechanisms are provided by the underlying language-agnostic host runtime and allow separation of concerns between guest and host runtime.\u0000 Guest language objects are stored on the host heap and managed by the host garbage collector. Multiple executing languages can share the same heap. This enables language interoperability without marshaling at the language boundary, because the field value of one language can point to an object of another language. Reusing the allocation system of the host runtime is another major simplification for guest language runtimes.\u0000 We implemented Truffle, the guest language runtime framework, on top of the Graal compiler and the HotSpot(TM) virtual machine. So far, there are prototypes for C, J, Python, JavaScript, R, Ruby, and Smalltalk running on top of the Truffle framework. The prototypes are still incomplete with respect to language sem","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"274 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":"124428091","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}

{"title":"Concolic testing with static analysis for JavaScript applications","authors":"Sora Bae","doi":"10.1145/2584469.2584471","DOIUrl":"https://doi.org/10.1145/2584469.2584471","url":null,"abstract":"JavaScript has given a great deal of impacts on the software industry. However, developers test JavaScript applications only with manually constructed test cases, which makes it difficult and time-consuming to obtain reasonable test coverage. Because of the loosely-typed and extremely dynamic features of JavaScript, generating nontrivial test inputs of certain forms only with existing testing algorithms has been challenging. Until recently, available assistance tools for testing JavaScript applications are relatively little compared to static languages such as Java and C#. In this paper, we introduce an automatic test generation tool, which combines concolic testing with static analysis. Using the static analysis results, our tool can generate nontrivial test inputs for JavaScript applications. We implement the tool on top of the SAFE framework using its static analyzer and a concolic test generation approach.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"15 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":"133292697","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}

{"title":"JavaScript API misuse detection by using typescript","authors":"Jihyeok Park","doi":"10.1145/2584469.2584472","DOIUrl":"https://doi.org/10.1145/2584469.2584472","url":null,"abstract":"Static analysis of JavaScript programs to detect errors in them is a challenging task. Especially when the program imports massive JavaScript libraries such as jQuery and MooTools, analyzing the whole program and the libraries is expensive and extremely declines the analysis efficiency. In this paper, we introduce a novel approach to solve the problem by modularizing the analysis. We separate the analysis of JavaScript libraries by using types extracted from their corresponding specifications in TypeScript and the analysis of JavaScript applications by a static analysis framework. We use DefinitelyTyped, an open-source repository that provides TypeScript declaration files of over 300 popular JavaScript libraries, and we extend SAFE, an open-source analysis framework for JavaScript.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"7 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":"121082815","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}

{"title":"Modularizing crosscutting contracts with AspectJML","authors":"Henrique Rebêlo, Gary T. Leavens, M. Bagherzadeh, Hridesh Rajan, R. Lima, D. M. Zimmerman, Márcio Cornélio, Thomas Thüm","doi":"10.1145/2584469.2584476","DOIUrl":"https://doi.org/10.1145/2584469.2584476","url":null,"abstract":"It is claimed in the literature that the contracts of a system present crosscutting structure during its realization. In this context, there has been attempts to improve separation of crosscutting contracts, e.g. by aspect-oriented programming and design by contract languages, but none give programmers textual separation of contracts/specifications and modular reasoning at the same time.\u0000 In this demonstration we show how our language, AspectJML, a simple and practical aspect-oriented extension to JML, allows the separation of crosscutting contracts while maintaining the key benefits of a design by contract language, like documentation and modular reasoning. AspectJML's quantified statements, written in terms of AspectJ pointcut language, allow one to select join points in which the contracts are written in a modular and convenient way. Also, all the crosscutting contracts are well documented in the class they apply to, thus allowing the reasoning about crosscutting contracts in a modular fashion.\u0000 This demonstration will proceed by discussing several examples that highlights the main features of the AspectJML language and show the use of AspectJML's compiler, ajmlc. We will conclude with a discussion of ongoing work on design, implementation and runtime checking of both Java and AspectJ programs with AspectJML/ajmlc.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"76 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":"116905318","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}

{"title":"Finding bugs in program generators by dynamic analysis of syntactic language constraints","authors":"Sebastian Erdweg, V. Vergu, M. Mezini, E. Visser","doi":"10.1145/2584469.2584474","DOIUrl":"https://doi.org/10.1145/2584469.2584474","url":null,"abstract":"Program generators and transformations are hard to implement correctly, because the implementation needs to generically describe how to construct programs, for example, using templates or rewrite rules. We apply dynamic analysis to program generators in order to support developers in finding bugs and identifying the source of the bug. Our analysis focuses on syntactic language constraints and checks that generated programs are syntactically well-formed. To retain a language's grammar as the unique specification of the language's syntax, we devised mechanisms to derive the analysis from the grammar. Moreover, we designed a run-time system to support the modular activation/deactivation of the analysis, so that generators do not require adaption. We have implemented the analysis for the Stratego term-rewriting language and applied it in case studies based on Spoofax and SugarJ.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"29 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":"125792567","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}

{"title":"Coccinelle: reducing the barriers to modularization in a large C code base","authors":"J. Lawall","doi":"10.1145/2584469.2584661","DOIUrl":"https://doi.org/10.1145/2584469.2584661","url":null,"abstract":"Coccinelle is a program matching and transformation tool for C code that has been extensively used for bug finding and evolutions in the Linux kernel. In this paper, we show how Coccinelle can be used in maintaining and improving the modularity of software, taking as a case study the introduction of an API providing a form of managed resources into the Linux kernel.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"6 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":"123637249","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}

{"title":"Relations: a first class relationship and first class derivations programming language","authors":"D. Harkes","doi":"10.1145/2584469.2584473","DOIUrl":"https://doi.org/10.1145/2584469.2584473","url":null,"abstract":"classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for third-party components of this work must be honored. For all other uses, contact the owner/author(s). Copyright is held by the author/owner(s). MODULARITY’14, April 22–26, 2014, Lugano, Switzerland. ACM 978-1-4503-2773-2/14/04. http://dx.doi.org/10.1145/2584469.2584473 Relations","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"111 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":"124702887","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}

{"title":"TouchRAM: a multitouch-enabled software design tool supporting concern-oriented reuse","authors":"Matthias Schöttle, Omar Alam, F. Garcia, G. Mussbacher, J. Kienzle","doi":"10.1145/2584469.2584475","DOIUrl":"https://doi.org/10.1145/2584469.2584475","url":null,"abstract":"TouchRAM is a multitouch-enabled tool for agile software design modelling aimed at developing scalable and reusable software design models. This paper primarily focusses on the new features that were added to TouchRAM to provide initial support for concern-orientation, and then summarizes the new extensions to behavioural modelling and improved integration with Java. A video that demonstrates the use of TouchRAM can be found here: http://www.youtube.com/watch?v=l8LMqwwRPg4","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"53 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":"129394265","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}

{"title":"Neverlang 2: a framework for modular language implementation","authors":"Edoardo Vacchi, Diego Mathias Olivares, A. Shaqiri, W. Cazzola","doi":"10.1145/2584469.2584478","DOIUrl":"https://doi.org/10.1145/2584469.2584478","url":null,"abstract":"Neverlang 2 is a JVM-based framework for language development that emphasizes code reuse through composition of language features. This paper is aimed at showing how to develop extensible, custom languages using Neverlang's component-based model of implementation. Using this model, each feature of the language can be implemented as a separate, conceptually isolated unit that can be compiled and distributed separately from the others. A live tutorial of the framework can be found at http://youtu.be/Szxvg7XLbXc","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"32 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":"129455328","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}

{"title":"iArch: an IDE for supporting fluid abstraction","authors":"Di Ai, Naoyasu Ubayashi, Peiyuan Li, Daisuke Yamamoto, Yu Ning Li, Shintaro Hosoai, Yasutaka Kamei","doi":"10.1145/2584469.2584477","DOIUrl":"https://doi.org/10.1145/2584469.2584477","url":null,"abstract":"Abstraction plays an important role in software development. Although it is preferable to firmly separate design from its implementation, this separation is not easy because an abstraction level tends to change during the progress of software development. It is not avoidable to fluidly go back and forth between design and implementation. An abstraction level of a design specification may change as a result of reconsidering the balance between design and code - which concern should be described in design and which concern should be written in code. The iArch IDE (Integrated Development Environment) supports the notion of fluid abstraction, a design approach in which an appropriate abstraction level can be captured by the convergence of fluid moving between design and implementation.","PeriodicalId":284672,"journal":{"name":"International Conference on Modularity","volume":"68 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":"127492345","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}