In this paper, we reflect on the first semester of a Computer Science capstone course focused on civic engagement projects. This was offered as an alternate section of an existing capstone, with multiple student teams working with a local non-profit. We describe how the student work was structured during the semester, as well as the activities leading up to the semester and occurring immediately after the semester. We also reflect on what worked well, and discuss potential changes in future semesters. We believe this will be helpful to other faculty that are either starting a new capstone course, or modifying an existing capstone course, that will engage community partners with student teams.
@inproceedings{hills-fenwick-2024-ccsc-se,author={Hills, Mark and {Fenwick, Jr.}, James B.},title={{Starting a Civic Engagement Capstone: An Experience Report}},booktitle={Papers of the 38th Annual CCSC Southeast Conference (CCSC-SE 2024)},pages.={84--95},year={2024},publisher={ACM},}
2023
A Comparison of Machine Learning Code Quality in Python Scripts and Jupyter Notebooks
Kyle
Adams, Aleksei
Vilkomir, and Mark
Hills
In Papers of the 37th Annual CCSC Southeast Conference (CCSC-SE 2023), 2023
Jupyter notebooks are currently one of the most popular environments for Python development, especially in domains such as data science. Existing studies have shown that notebooks may promote bad coding habits, leading to poor code quality and challenges with replicating notebook results. In this paper, we compare the code quality of Python machine learning code found in Jupyter notebooks to that found in regular Python scripts. The goal of this work is to better understand how the machine learning code created in Jupyter notebooks differs both from machine learning code provided in scripts and from the larger body of Python code, with the aim of creating tools to better support both data science students and practitioners.
@inproceedings{adams-vilkomir-hills-2023-ccsc-se,author={Adams, Kyle and Vilkomir, Aleksei and Hills, Mark},title={{A Comparison of Machine Learning Code Quality in Python Scripts and Jupyter Notebooks}},booktitle={Papers of the 37th Annual CCSC Southeast Conference (CCSC-SE 2023)},year={2023},publisher={ACM},pages={96--108},}
Enabling Go Program Analysis in Rascal
Luke
Swearngan and Mark
Hills
In Proceedings of the 23rd IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2023), 2023
In this paper, we present early work on the foundation of a program analysis framework for the Go programming language. This framework, named Go AiR (Analysis in Rascal), currently provides support for extracting abstract syntax trees from Go source code, working with multiple Go projects and multiple versions of a single Go project (based on Git version history), and code exploration through the use of Rascal features for working with representations of source code. We discuss the structure of the framework, describe the mapping from Go to Rascal and how this was tested, present sample code showing how the framework can be used to explore Go source code, and discuss future extensions to the framework to support program analysis and verification.
@inproceedings{swearngan-hills-2023-scam,author={Swearngan, Luke and Hills, Mark},title={{Enabling Go Program Analysis in Rascal}},booktitle={Proceedings of the 23rd {IEEE} International Working Conference on Source Code Analysis and Manipulation (SCAM 2023)},pages={242--247},year={2023},publisher={IEEE},doi={10.1109/SCAM59687.2023.00033},}
2021
Foundations
Carolyn
Talcott, Sofia
Ananieva, Kyungmin
Bae, and
10 more authors
@inbook{talcott-etal-foundations,author={Talcott, Carolyn and Ananieva, Sofia and Bae, Kyungmin and Combemale, Benoit and Heinrich, Robert and Hills, Mark and Khakpour, Narges and Reussner, Ralf and Rumpe, Bernhard and Scandurra, Patrizia and Vangheluwe, Hans and Dur{\'a}n, Francisco and Zschaler, Steffen},editor={Heinrich, Robert and Dur{\'a}n, Francisco and Talcott, Carolyn and Zschaler, Steffen},title={Foundations},booktitle={Composing Model-Based Analysis Tools},year={2021},publisher={Springer International Publishing},address={Cham},pages={9--37},isbn={978-3-030-81915-6},doi={10.1007/978-3-030-81915-6_2},url={https://doi.org/10.1007/978-3-030-81915-6_2},}
Composition of Languages, Models, and Analyses
Carolyn
Talcott, Sofia
Ananieva, Kyungmin
Bae, and
8 more authors
@inbook{talcott-etal-composition,author={Talcott, Carolyn and Ananieva, Sofia and Bae, Kyungmin and Combemale, Benoit and Heinrich, Robert and Hills, Mark and Khakpour, Narges and Reussner, Ralf and Rumpe, Bernhard and Scandurra, Patrizia and Vangheluwe, Hans},editor={Heinrich, Robert and Dur{\'a}n, Francisco and Talcott, Carolyn and Zschaler, Steffen},title={Composition of Languages, Models, and Analyses},booktitle={Composing Model-Based Analysis Tools},year={2021},publisher={Springer International Publishing},address={Cham},pages={45--70},isbn={978-3-030-81915-6},doi={10.1007/978-3-030-81915-6_4},url={https://doi.org/10.1007/978-3-030-81915-6_4},}
Planning a Conceptual Framework Approach for Teaching Cloud Fundamentals
James H.
Paterson, Joshua
Adams, Laurie
White, and
9 more authors
In ITiCSE 2021: 26th ACM Conference on Innovation and Technology in
Computer Science Education, Virtual Event, Germany, June 26 - July
1, 2021 - Working Group Reports, 2021
Three previous Working Groups (WG) have met at ITiCSE conferences to explore ways of incorporating cloud computing into courses and curricula by mapping industry job skills to knowledge areas (KAs) and KAs to student learning objectives (LOs) and using these as the framework for a repository of learning materials and course exemplars. The ongoing value of the work of these WGs will be enhanced by validating the KAs and LOs and their mapping to current job skills and continuing to build a community of educators who will contribute to and benefit from the repository. This WG aims to make a significant contribution to the achievement of both aims. It will focus on planning for a wider, ongoing research study for validation of the mapped KAs and LOs and will create and pilot a model for workshops which will contribute to community building and help to frame the research plan.
@inproceedings{paterson-etal-wgabstract-2021,author={Paterson, James H. and Adams, Joshua and White, Laurie and Csizmadia, Andrew and Erdil, Deger Cenk and Foster, Derek and Hills, Mark and Kazmi, Zain and Kuber, Karthik and Nazir, Sajid and Sakr, Majd and Stott, Lee},editor={Schulte, Carsten and Becker, Brett A. and Divitini, Monica and Barendsen, Erik},title={Planning a Conceptual Framework Approach for Teaching Cloud Fundamentals},booktitle={ITiCSE 2021: 26th {ACM} Conference on Innovation and Technology in
Computer Science Education, Virtual Event, Germany, June 26 - July
1, 2021 - Working Group Reports},pages={605--606},publisher={{ACM}},year={2021},url={https://doi.org/10.1145/3456565.3461443},doi={10.1145/3456565.3461443},timestamp={Thu, 14 Oct 2021 10:06:24 +0200},biburl={https://dblp.org/rec/conf/iticse/PatersonAWCEF0K21.bib},bibsource={dblp computer science bibliography, https://dblp.org},}
Designing Dissemination and Validation of a Framework for Teaching
Cloud Fundamentals
James H.
Paterson, Joshua
Adams, Laurie
White, and
9 more authors
In Proceedings of the 2021 Working Group Reports on Innovation and Technology
in Computer Science Education, ITiCSE-WGR 2021, Virtual Event Germany,
26 June 2021- 1 July 2021, 2021
Three previous Working Groups (WGs) met at ITiCSE conferences to explore ways to help educators incorporate cloud computing into their courses and curricula by mapping industry job skills to knowledge areas (KAs). These WGs identified, organized, and grouped together student learning objectives (LOs) and developed these KAs and LOs in a repository of learning materials and course exemplars. This WG focused on the sustainability of the work of its predecessors through dissemination, community building and validation of the framework of KAs and LOs and its contribution to curriculum development. Firstly, a case study is presented which analyzed the implementation of a new Masters program which was based on the KAs and LOs. It was found that these provide a useful basis for program development and approval and demonstrate that successful program development of this nature can provide a valuable opportunity to communicate the work of the previous WGs. Thereafter, a plan was formulated for dissemination of the work done in order to drive adoption and to encourage instructors with an interest in teaching cloud computing to participate and grow the community. While the strategy included a range of dissemination methods, the importance of interaction with users was a guiding principle. Initial pilots of webinar and workshop activities have been implemented.
@inproceedings{paterson-etal-wgreport-2021,author={Paterson, James H. and Adams, Joshua and White, Laurie and Csizmadia, Andrew and Erdil, Deger Cenk and Foster, Derek and Hills, Mark and Kazmi, Zain and Kuber, Karthik and Nazir, Sajid and Sakr, Majd and Stott, Lee},title={Designing Dissemination and Validation of a Framework for Teaching
Cloud Fundamentals},booktitle={Proceedings of the 2021 Working Group Reports on Innovation and Technology
in Computer Science Education, ITiCSE-WGR 2021, Virtual Event Germany,
26 June 2021- 1 July 2021},pages={163--181},publisher={{ACM}},year={2021},url={https://doi.org/10.1145/3502870.3506569},doi={10.1145/3502870.3506569},timestamp={Sat, 31 May 2025 23:11:16 +0200},biburl={https://dblp.org/rec/conf/iticse/PatersonAWCEFHK21.bib},bibsource={dblp computer science bibliography, https://dblp.org},}
2020
Introducing DevOps Techniques in a Software Construction Class
Mark
Hills
In Proceedings of the 32nd IEEE International Conference on Software Engineering Education and Training (CSEE&T 2020), 2020
As more companies adopt techniques related to DevOps and continuous deployment, it is critical for students in software engineering courses to gain hands-on experience with these techniques. In this paper, we describe a collection of assignments given in a graduate software construction class that guides students through the process of creating Docker containers, configuring continuous integration services, constructing a build pipeline, and automating deployment of new versions of a software system when changes are committed to the code repository. We also briefly analyze the performance of students on these hands-on exercises, identifying areas where additional support is needed to ensure student success.
@inproceedings{hills-2020-cseet,author={Hills, Mark},title={{Introducing DevOps Techniques in a Software Construction Class}},booktitle={Proceedings of the 32nd IEEE International Conference on Software Engineering Education and Training (CSEE&T 2020)},year={2020},pages={85--89},publisher={IEEE},doi={10.1109/CSEET49119.2020.9206183},}
Cloud Computing Curriculum: Developing Exemplar Modules for General
Course Inclusion
Joshua
Adams, Brian
Hainey, Laurie
White, and
9 more authors
In Proceedings of the 2020 ACM Conference on Innovation and Technology
in Computer Science Education, ITiCSE 2020, Trondheim, Norway, June
15-19, 2020, 2020
The accelerating evolution and adoption of cloud computing services is generating increased demand for job skills in this domain. To address this growth, higher education has identified the importance of cloud computing courses that are practical and compatible with this rapidly changing field. This is especially relevant as cloud services are becoming common computing resources for many new computational approaches and advanced subjects such as machine learning and data science. The ability to incorporate specific components of cloud computing teaching content into a variety of courses has become important. However, the lack of availability of high-quality teaching material that is easy to integrate, when teaching rapidly evolving cloud-related concepts continues to be a challenge for instructors. This working group will try to address this challenge.
@inproceedings{adams-etal-wgabstract-2020,author={Adams, Joshua and Hainey, Brian and White, Laurie and Foster, Derek and Hall, Narine and Hills, Mark and Hooshangi, Sara and Kuber, Karthik and Nazir, Sajid and Sakr, Majd and Stott, Lee and Taglienti, Carmen},editor={Giannakos, Michail N. and Sindre, Guttorm and Luxton{-}Reilly, Andrew and Divitini, Monica},title={{Cloud Computing Curriculum: Developing Exemplar Modules for General
Course Inclusion}},booktitle={Proceedings of the 2020 {ACM} Conference on Innovation and Technology
in Computer Science Education, ITiCSE 2020, Trondheim, Norway, June
15-19, 2020},pages={510--511},publisher={{ACM}},year={2020},url={https://doi.org/10.1145/3341525.3394992},doi={10.1145/3341525.3394992},timestamp={Sun, 14 Jun 2020 11:17:19 +0200},biburl={https://dblp.org/rec/conf/iticse/AdamsHWFH0HKNSS20.bib},bibsource={dblp computer science bibliography, https://dblp.org},}
Cloud Computing Curriculum: Developing Exemplar Modules for General
Course Inclusion
Joshua
Adams, Brian
Hainey, Laurie
White, and
9 more authors
In Proceedings of the Working Group Reports on Innovation and Technology
in Computer Science Education, ITiCSE 2020, Trondheim, Norway, June
15-19, 2020, 2020
The accelerating evolution and adoption of cloud computing services is generating increased demand for job skills in this domain. To address this growth, higher education has identified the importance of cloud computing courses that deliver practical and hands-on material relevant to this rapidly evolving field. This is especially relevant as cloud services are quickly becoming the standard computing model for many new computational approaches, including advanced subjects such as machine learning and data science. Since cloud computing influences a number of other traditional computing subjects such as networking and data storage, the ability to incorporate specific components of cloud computing teaching content into a variety of courses has also become important. However, a lack of availability of high-quality teaching material that is easy to integrate, when teaching rapidly evolving cloud-related concepts, continues to be a challenge for instructors. As the volume of teaching material that educators and other providers are willing to share increases, it is important that the content is easily discoverable and accurately catalogued. Using appropriate Learning Objectives (LOs) and tags associated with the correct course material contributes toward a reliable and trustworthy source for faculty. This Working Group (WG) has addressed these challenges by 1) creating a canonical list of LOs, based on the LOs included in the Knowledge Areas (KAs) developed by the ITiCSE working groups in 2018 and 2019; 2) searching for existing teaching material, cataloging the material by LO and then combining the LOs into exemplar modules for some of the more common classes that adopt cloud computing; 3) creating sample syllabi for these exemplars following the ACM Computer Science Curricula 2013 approach; and 4) developing a solution for disseminating the materials and keeping them up to date.
@inproceedings{adams-etal-wgreport-2020,author={Adams, Joshua and Hainey, Brian and White, Laurie and Foster, Derek and Hall, Narine and Hills, Mark and Hooshangi, Sara and Kuber, Karthik and Nazir, Sajid and Sakr, Majd and Stott, Lee and Taglienti, Carmen},editor={Giannakos, Michail N. and Sindre, Guttorm and Luxton{-}Reilly, Andrew and Divitini, Monica},title={Cloud Computing Curriculum: Developing Exemplar Modules for General
Course Inclusion},booktitle={Proceedings of the Working Group Reports on Innovation and Technology
in Computer Science Education, ITiCSE 2020, Trondheim, Norway, June
15-19, 2020},pages={151--172},publisher={{ACM}},year={2020},url={https://doi.org/10.1145/3437800.3439206},doi={10.1145/3437800.3439206},timestamp={Thu, 14 Oct 2021 10:06:25 +0200},biburl={https://dblp.org/rec/conf/iticse/AdamsHWFH0HKNSS20a.bib},bibsource={dblp computer science bibliography, https://dblp.org},}
2017
Query Construction Patterns in PHP
David
Anderson and Mark
Hills
In Proceedings of the 24th IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2017), 2017
Most PHP applications use databases, with developers including both static queries, given directly in the code, and dynamic queries, which are based on a mixture of static text, computed values, and user input. In this paper, we focus specifically on how developers create queries that are then used with the original MySQL API library. Based on a collection of open-source PHP applications, our initial results show that many of these queries are created according to a small collection of query construction patterns. We believe that identifying these patterns provides a solid base for program analysis, comprehension, and transformation tools that need to reason about database queries, including tools to support renovating existing PHP code to support safer, more modern database access APIs.
@inproceedings{anderson-hills-2017-saner,author={Anderson, David and Hills, Mark},title={{Query Construction Patterns in PHP}},booktitle={Proceedings of the 24th {IEEE} International Conference on Software Analysis, Evolution, and Reengineering (SANER 2017)},pages={452-456},year={2017},publisher={IEEE},doi={10.1109/SANER.2017.7884652},}
Supporting Analysis of SQL Queries in PHP AiR
David
Anderson and Mark
Hills
In Proceedings of the 17th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2017), 2017
The code behind dynamic webpages often includes calls to database libraries, with queries formed using a combination of static text and values computed at runtime. In this paper, we describe our work on a program analysis for extracting models of database queries that can compactly represent all queries that could be used in a specific database library call. We also describe our work on parsing partial queries, with holes representing parts of the query that are computed dynamically. Implemented in Rascal as part of the PHP AiR framework, the goal of this work is to enable empirical research on database usage in PHP scripts, to support developer tools for understanding existing queries, and to support program transformation tools to evolve existing systems and to improve the security of existing code.
@inproceedings{anderson-hills-2017-scam,author={Anderson, David and Hills, Mark},title={{Supporting Analysis of SQL Queries in PHP AiR}},booktitle={Proceedings of the 17th {IEEE} International Working Conference on Source Code Analysis and Manipulation (SCAM 2017)},pages={153--158},year={2017},publisher={IEEE},doi={10.1109/SCAM.2017.23},}
Enabling PHP Software Engineering Research in Rascal
Today, PHP is one of the most popular programming languages, and is commonly used in the open source community and in industry to build large application frameworks and web applications. In this paper, we discuss our ongoing work on PHP AiR, a framework for PHP Analysis in Rascal. PHP AiR is focused especially on program analysis and empirical software engineering, and is being used actively and effectively in work on evaluating PHP feature usage and system evolution, on program analysis for refactoring and security validation, and on source code metrics. We describe the requirements and design decisions for PHP AiR, summarize current research using PHP AiR, discuss lessons learned, and briefly sketch future work.
@inproceedings{hills-klint-vinju-2017-scp,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{Enabling PHP Software Engineering Research in Rascal}},journal={Science of Computer Programming},volume={134},pages={37--46},year={2017},publisher={Elsevier},doi={10.1016/j.scico.2016.05.003},}
2016
Navigating the WordPress Plugin Landscape
Mark
Hills
In Proceedings of the 24th IEEE International Conference on Program Comprehension (ICPC 2016), 2016
WordPress includes a plugin mechanism that allows user-provided code to be executed in response to specific system events and input/output requests. The large number of extension points provided by WordPress makes it challenging for new plugin developers to understand which extension points they should use, while the thousands of existing plugins make it hard to find existing extension point handler implementations for use as examples when creating a new plugin. In this paper, we present a lightweight analysis, supplemented with information mined from source comments and the webpages hosted by WordPress for each plugin, that guides developers to the right extension points and to existing implementations of handlers for these extension points. We also present empirical information about how plugins are used in practice, providing guidance to both tool and prospective plugin developers.
@inproceedings{hills-2016-icpc,author={Hills, Mark},title={{Navigating the WordPress Plugin Landscape}},booktitle={Proceedings of the 24th IEEE International Conference on Program Comprehension (ICPC 2016)},pages={1--10},year={2016},publisher={IEEE},doi={10.1109/ICPC.2016.7503709},}
2015
Evolution of Dynamic Feature Usage in PHP
Mark
Hills
In Proceedings of the 22nd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2015), 2015
PHP includes a number of dynamic features that, if used, make it challenging for both programmers and tools to reason about programs. In this paper we examine how usage of these features has changed over time, looking at usage trends for three categories of dynamic features across the release histories of two popular open-source PHP systems, WordPress and MediaWiki. Our initial results suggest that, while features such as eval are being removed over time, more constrained dynamic features such as variable properties are becoming more common. We believe the results of this analysis provide useful insights for researchers and tool developers into the evolving use of dynamic features in real PHP programs.
@inproceedings{hills-2015-saner,author={Hills, Mark},title={{Evolution of Dynamic Feature Usage in PHP}},booktitle={Proceedings of the 22nd {IEEE} International Conference on Software Analysis, Evolution, and Reengineering (SANER 2015)},pages={525--529},year={2015},publisher={IEEE},doi={10.1109/SANER.2015.7081870},}
Modular language implementation in Rascal - experience report
Bas
Basten, Jeroen
van den Bos, Mark
Hills, and
6 more authors
All software evolves, and programming languages and programming language tools are no exception. And just like in ordinary software construction, modular implementations can help ease the process of changing a language implementation and its dependent tools. However, the syntactic and semantic dependencies between language features make this a challenging problem. In this paper we detail how programming languages can be implemented in a modular fashion using the Rascal meta-programming language. Rascal supports extensible definition of concrete syntax, abstract syntax and operations on concrete and abstract syntax trees like matching, traversal and transformation. As a result, new language features can be added without having to change existing code. As a case study, we detail our solution of the LDTA’11 Tool Challenge: a modular implementation of Oberon-0, a relatively simple imperative programming language. The approach we sketch can be applied equally well to the implementation of domain-specific languages.
@article{basten-bos-etal-2015-scp,author={Basten, Bas and {van den Bos}, Jeroen and Hills, Mark and Klint, Paul and Lankamp, Arnold and Lisser, Bert and {van der Ploeg}, Atze and {van der Storm}, Tijs and Vinju, Jurgen J.},title={{Modular language implementation in Rascal - experience report}},journal={Science of Computer Programming},volume={114},pages={7--19},year={2015},publisher={Elsevier},doi={10.1016/j.scico.2015.11.003},}
M3: A General Model for Code Analytics in Rascal
Bas
Basten, Mark
Hills, Paul
Klint, and
4 more authors
In Proceedings of the 1st IEEE International Workshop on Software Analytics (SWAN 2015), 2015
This short paper introduces M3, a simple and extensible model for capturing facts about source code for future analysis. M3 is a core part of the standard library of the Rascal meta programming language. We motivate it, position it to related work and detail the key design aspects.
@inproceedings{m3-2015-swan,author={Basten, Bas and Hills, Mark and Klint, Paul and Landman, Davy and Shahi, Ashim and Steindorfer, Michael J. and Vinju, Jurgen J.},title={{M3: A General Model for Code Analytics in Rascal}},booktitle={Proceedings of the 1st IEEE International Workshop on Software Analytics (SWAN 2015)},pages={25--28},year={2015},publisher={IEEE},doi={10.1109/SWAN.2015.7070485},}
Supporting PHP Dynamic Analysis in PHP AiR
Mark
Hills
In Proceedings of the 13th International Workshop on Dynamic Analysis (WODA at SPLASH 2015), 2015
The PHP AiR framework is currently being developed to support software metrics, empirical software engineering, and program analysis for real-world PHP systems. While most of the work on program analysis has focused on static analysis, to help address the dynamic nature of the language we have also started to extend PHP AiR with support for dynamic program analysis. This extended abstract highlights two parts of this support: integration with xdebug for trace analysis, and instrumentation of an open-source PHP interpreter with a focus on supporting string origins, allowing us to explore how strings are created in security-sensitive areas such as database calls and HTML generation.
@inproceedings{hills-2015-woda,author={Hills, Mark},title={{Supporting PHP Dynamic Analysis in PHP AiR}},booktitle={Proceedings of the 13th International Workshop on Dynamic Analysis (WODA at SPLASH 2015)},pages={37--38},year={2015},publisher={ACM},doi={10.1145/2823363.2823373},}
Variable Feature Usage Patterns in PHP
Mark
Hills
In Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering (ASE 2015), 2015
PHP allows the names of variables, classes, functions, methods, and properties to be given dynamically, as expressions that, when evaluated, return an identifier as a string. While this provides greater flexibility for programmers, it also makes PHP programs harder to precisely analyze and understand. In this paper we present a number of patterns designed to recognize idiomatic uses of these features that can be statically resolved to a precise set of possible names. We then evaluate these patterns across a corpus of 20 open-source systems totaling more than 3.7 million lines of PHP, showing how often these patterns occur in actual PHP code, demonstrating their effectiveness at statically determining the names that can be used at runtime, and exploring anti-patterns that indicate when the identifier computation is truly dynamic.
@inproceedings{hills-2015-ase,author={Hills, Mark},title={{Variable Feature Usage Patterns in PHP}},booktitle={Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering (ASE 2015)},year={2015},pages={563--573},publisher={IEEE},doi={10.1109/ASE.2015.72},}
In Proceedings of the IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering (CSMR-WCRE), 2014 Software Evolution Week (CSMR-WCRE 2014), 2014
PHP is currently one of the most popular programming languages, widely used in both the open source community and in industry to build large web-focused applications and application frameworks. To provide a solid framework for working with large PHP systems in areas such as evaluating how language features are used, studying how PHP systems evolve, program analysis for refactoring and security validation, and software metrics, we have developed PHP AiR, a framework for PHP Analysis in Rascal. Here we briefly describe features available in PHP AiR, integration with the Eclipse PHP Development Tools, and usage scenarios in program analysis, metrics, and empirical software engineering.
@inproceedings{hills-klint-2014-csmr-wcre,author={Hills, Mark and Klint, Paul},title={{PHP AiR: Analyzing PHP Systems with Rascal}},publisher={IEEE},booktitle={Proceedings of the IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering (CSMR-WCRE), 2014 Software Evolution Week (CSMR-WCRE 2014)},year={2014},pages={454--457},doi={10.1109/CSMR-WCRE.2014.6747217},}
Streamlining Control Flow Graph Construction with DCFlow
Mark
Hills
In Proceedings of the 7th International Conference on Software Language Engineering (SLE 2014), 2014
A control flow graph (CFG) is used to model possible paths through a program, and is an essential part of many program analysis algorithms. While programs to construct CFGs can be written in meta-programming languages such as Rascal, writing such programs is currently quite tedious. With the goal of streamlining this process, in this paper we present DCFlow, a domain-specific language and Rascal library for defining control flow rules and building control flow graphs. Control flow rules in DCFlow are defined declaratively, based directly on the abstract syntax of the language under analysis and a number of operations representing types of control flow. Standard Rascal code is then generated based on the DCFlow definition. This code makes use of the DCFlow libraries to build CFGs for programs, which can then be visualized or used inside program analysis algorithms. To demonstrate the design of DCFlow we apply it to Pico—a very simple imperative language—and to a significant subset of PHP.
@inproceedings{hills-2014-sle,author={Hills, Mark},title={{Streamlining Control Flow Graph Construction with DCFlow}},booktitle={Proceedings of the 7th International Conference on Software Language Engineering (SLE 2014)},pages={322--341},series={Lecture Notes in Computer Science},volume={8706},publisher={Springer},year={2014},doi={10.1007/978-3-319-11245-9_18},}
Dynamic languages include a number of features that are challenging to model properly in static analysis tools. In PHP, one of these features is the include expression, where an arbitrary expression provides the path of the file to include at runtime. In this paper we present two complementary analyses for statically resolving PHP includes, one that works at the level of individual PHP files, and one targeting PHP programs possibly consisting of multiple scripts. To evaluate the effectiveness of these analyses we have applied the first to a corpus of 20 open-source systems, totaling more than 4.5 million lines of PHP, and the second to a number of programs from a subset of these systems. Our results show that, in many cases, includes can be resolved to a specific file or a small subset of possible files, enabling better IDE features and more advanced program analysis tools for PHP.
@inproceedings{hills-klint-vinju-2014-ase,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{Static, Lightweight Includes Resolution for PHP}},booktitle={Proceedings of the 29th {ACM/IEEE} International Conference on Automated Software Engineering (ASE 2014)},pages={503--514},year={2014},publisher={ACM},doi={10.1145/2642937.2643017},}
2013
An Empirical Study of PHP Feature Usage: A Static Analysis Perspective
PHP is one of the most popular languages for server-side application development. The language is highly dynamic, providing programmers with a large amount of flexibility. However, these dynamic features also have a cost, making it difficult to apply traditional static analysis techniques used in standard code analysis and transformation tools. As part of our work on creating analysis tools for PHP, we have conducted a study over a significant corpus of open-source PHP systems, looking at the sizes of actual PHP programs, which features of PHP are actually used, how often dynamic features appear, and how distributed these features are across the files that make up a PHP website. We have also looked at whether uses of these dynamic features are truly dynamic or are, in some cases, statically understandable, allowing us to identify specific patterns of use which can then be taken into account to build more precise tools. We believe this work will be of interest to creators of analysis tools for PHP, and that the methodology we present can be leveraged for other dynamic languages with similar features.
@inproceedings{hills-klint-vinju-2013-issta,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{An Empirical Study of PHP Feature Usage: A Static Analysis Perspective}},booktitle={Proceedings of the 2013 International Symposium on Software Testing and Analysis (ISSTA 2013)},publisher={ACM},year={2013},pages={325--335},doi={10.1145/2483760.2483786},}
2012
Meta-language Support for Type-Safe Access to External Resources
Meta-programming applications often require access to heterogeneous sources of information, often from different technological spaces (grammars, models, ontologies, databases), that have specialized ways of defining their respective data schemas. Without direct language support, obtaining typed access to this external, potentially changing, information is a tedious and error-prone engineering task. The Rascal meta-programming language aims to support the import and manipulation of all of these kinds of data in a type- safe manner. The goal is to lower the engineering effort to build new meta programs that combine information about software in unforeseen ways. In this paper we describe built-in language support, so called resources, for incorporating external sources of data and their corresponding data-types while maintaining type safety. We demonstrate the applicability of Rascal resources by example, showing resources for RSF files, CSV files, JDBC- accessible SQL databases, and SDF2 grammars. For RSF and CSV files this requires a type inference step, allowing the data in the files to be loaded in a type-safe manner without requiring the type to be declared in advance. For SQL and SDF2 a direct translation from their respective schema languages into Rascal is instead constructed, providing a faithful translation of the declared types or sorts into equivalent types in the Rascal type system. An overview of related work and a discussion conclude the paper.
@inproceedings{hills-klint-vinju-2012-sle,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{Meta-language Support for Type-Safe Access to External Resources}},booktitle={Proceedings of the 5th International Conference on Software Language Engineering (SLE 2012)},year={2012},pages={372--391},publisher={Springer},series={Lecture Notes in Computer Science},volume={7745},doi={10.1007/978-3-642-36089-3_21},}
Rascal is a meta programming language focused on the implementation of domain-specific languages and on the rapid construction of tools for software analysis and software transformation. In this paper we focus on the use of Rascal for software analysis. We illustrate a range of scenarios for building new software analysis tools through a number of examples, including one showing integration with an existing Maude-based analysis. We then focus on ongoing work on alias analysis and type inference for PHP, showing how Rascal is being used, and sketching a hypothetical solution in Maude. We conclude with a high-level discussion on the commonalities and differences between Rascal and Maude when applied to program analysis.
@inproceedings{hills-klint-vinju-2012-wrla,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{Program Analysis Scenarios in Rascal}},booktitle={Proceedings of the 9th International Workshop on Rewriting Logic and its Applications (WRLA 2012)},year={2012},publisher={Springer},series={Lecture Notes in Computer Science},volume={7571},pages={10--30},doi={10.1007/978-3-642-34005-5_2},}
To facilitate experimentation with creating new, complex refactorings, we want to reuse existing transformation and analysis code as orchestrated parts of a larger refactoring: i.e., to script refactorings. The language we use to perform this scripting must be able to deal with the diversity of languages, tools, analyses, and transformations that arise in practice. To illustrate one solution to this problem, in this paper we describe, in detail, a specific refactoring script for switching from the Visitor design pattern to the Interpreter design pattern. This script, written in the meta-programming language Rascal, and targeting an interpreter written in Java, extracts facts from the interpreter code using the Eclipse JDT, performs the needed analysis in Rascal, and then transforms the interpreter code using a combination of Rascal code and existing JDT refactorings. Using this script we illustrate how a new, real and complex refactoring can be scripted in a few hundred lines of code and within a short timeframe. We believe the key to successfully building such refactorings is the ability to pair existing tools, focused on specific languages, with general-purpose meta-programming languages.
@inproceedings{hills-klint-vinju-2012-wrt,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{Scripting a Refactoring with Rascal and Eclipse}},booktitle={Proceedings of the Fifth Workshop on Refactoring Tools (WRT 2012)},year={2012},pages={40--49},publisher={ACM},doi={10.1145/2328876.2328882},}
A Rewriting Logic Approach to Static Checking of Units of Measurement in C
Many C programs assume the use of implicit domain-specific information. A common example is units of measurement, where values can have both a standard C type and an associated unit. However, since there is no way in the C language to represent this additional information, violations of domain-specific policies, such as unit safety violations, can be difficult to detect. In this paper we present a static analysis, based on the use of an abstract C semantics defined using rewriting logic, for the detection of unit violations in C programs. In contrast to typed approaches, the analysis makes use of annotations present in C comments on function headers and in function bodies, leaving the C language unchanged. Initial evaluation results show that performance scales well, and that errors can be detected without imposing a heavy annotation burden.
@inproceedings{hills-chen-rosu-2008-rule,author={Hills, Mark and Chen, Feng and Ro\c{s}u, Grigore},title={{A Rewriting Logic Approach to Static Checking of Units of Measurement in C}},booktitle={Proceedings of the Ninth International Workshop on Rule-Based Programming (RULE 2008)},year={2012},series={ENTCS},volume={290},pages={51--67},publisher={Elsevier},doi={10.1016/j.entcs.2012.11.011},}
A One-Stop-Shop for Software Evolution Tool Construction
Real problems in software evolution render impossible a fixed, one-size-fits-all approach, and these problems are usually solved by gluing together various tools and languages. Such ad-hoc integration is cumbersome and costly. With the Rascal meta-programming language the Software Analysis and Transformation research group at CWI explores whether it is feasible to develop an approach that offers all necessary meta-programming and visualization techniques in a completely integrated language environment. We have applied Rascal with success in constructing domain specific languages and experimental refactoring and visualization tools.
@article{ercim-news-2012,author={Hills, Mark and Klint, Paul and {van der Storm}, Tijs and Vinju, Jurgen},title={{A One-Stop-Shop for Software Evolution Tool Construction}},journal={ERCIM News},volume={2012},number={88},year={2012},pages={11-12},url={https://ercim-news.ercim.eu/en88},}
2011
RLSRunner: Linking Rascal with K for Program Analysis
The Rascal meta-programming language provides a number of features supporting the development of program analysis tools. However, sometimes the analysis to be developed is already implemented by another system. In this case, Rascal can provide a useful front-end for this system, handling the parsing of the input program, any transformation (if needed) of this program into individual analysis tasks, and the display of the results generated by the analysis. In this paper we describe a tool, RLSRunner, which provides this integration with static analysis tools defined using the K framework, a rewriting-based framework for defining the semantics of programming languages.
@inproceedings{hills-klint-vinju-2011-sle,author={Hills, Mark and Klint, Paul and Vinju, Jurgen J.},title={{RLSRunner: Linking Rascal with K for Program Analysis}},booktitle={Proceedings of the 4th International Conference on Software Language Engineering (SLE 2011)},publisher={Springer},series={Lecture Notes in Computer Science},volume={6940},year={2011},pages={344--353},doi={10.1007/978-3-642-28830-2_19},}
We compare the Visitor pattern with the Interpreter pattern, investigating a single case in point for the Java language. We have produced and compared two versions of an interpreter for a programming language. The first version makes use of the Visitor pattern. The second version was obtained by using an automated refactoring to transform uses of the Visitor pattern to uses of the Interpreter pattern. We compare these two nearly equivalent versions on their maintenance characteristics and execution efficiency. Using a tailored experimental research method we can highlight differences and the causes thereof. The contributions of this paper are that it isolates the choice between Visitor and Interpreter in a realistic software project and makes the difference experimentally observable.
@inproceedings{hills-klint-etal-2011-tools,author={Hills, Mark and Klint, Paul and {van der Storm}, Tijs and Vinju, J. J.},title={{A Case of Visitor versus Interpreter Pattern}},booktitle={Proceedings of the 49th International Conference on Objects, Models, Components, Patterns (TOOLS 2011)},year={2011},series={Lecture Notes in Computer Science},publisher={Springer},volume={6705},pages={228--243},doi={10.1007/978-3-642-21952-8_17},}
Rascal: From Algebraic Specification to Meta-Programming
Jeroen
van den Bos, Mark
Hills, Paul
Klint, and
2 more authors
In Proceedings of the Second International Workshop on Algebraic Methods in Model-Based Software Engineering (AMMSE 2011), 2011
Algebraic specification has a long tradition in bridging the gap between specification and programming by making specifications executable. Building on extensive experience in designing, implementing and using specification formalisms that are based on algebraic specification and term rewriting (namely ASF and ASF+SDF), we are now focusing on using the best concepts from algebraic specification and integrating these into a new programming language: Rascal. This language is easy to learn by non-experts but is also scalable to very large meta-programming applications. We explain the algebraic roots of Rascal and its main application areas: software analysis, software transformation, and design and implementation of domain-specific languages. Some example applications in the domain of Model-Driven Engineering (MDE) are described to illustrate this.
@inproceedings{bos-hills-etal-2011-ammse,author={{van den Bos}, Jeroen and Hills, Mark and Klint, Paul and {van der Storm}, Tijs and Vinju, Jurgen J.},title={{Rascal: From Algebraic Specification to Meta-Programming}},booktitle={Proceedings of the Second International Workshop on Algebraic Methods in Model-Based Software Engineering (AMMSE 2011)},series={EPTCS},volume={56},year={2011},pages={15--32},doi={10.4204/EPTCS.56.2},}
2010
A Rewriting Logic Semantics Approach to Modular Program Analysis
The K framework, based on rewriting logic semantics, provides a powerful logic for defining the semantics of programming languages. While most work in this area has focused on defining an evaluation semantics for a language, it is also possible to define an abstract semantics that can be used for program analysis. Using the SILF language (Hills, Serbanuta and Rosu, 2007), this paper describes one technique for defining such a semantics: policy frameworks. In policy frameworks, an analysis-generic, modular framework is first defined for a language. Individual analyses, called policies, are then defined as extensions of this framework, with each policy defining analysis-specific semantic rules and an annotation language which, in combination with support in the language front- end, allows users to annotate program types and functions with information used during program analysis. Standard term rewriting techniques are used to analyze programs by evaluating them in the policy semantics.
@inproceedings{hills-rosu-2010-rta,author={Hills, Mark and Ro\c{s}u, Grigore},title={{A Rewriting Logic Semantics Approach to Modular Program Analysis}},booktitle={Proceedings of the 21st International Conference on Rewriting Techniques and Applications (RTA 2010)},series={Leibniz International Proceedings in Informatics},pages={151--160},year={2010},volume={6},publisher={Schloss Dagstuhl - Leibniz Center of Informatics},doi={10.4230/LIPIcs.RTA.2010.151},}
2009
A Modular Rewriting Approach to Language Design, Evolution and Analysis
Mark
Hills
University of Illinois at Urbana-Champaign (UIUC), Dec 2009
Software is becoming a pervasive presence in our lives, powering computing systems in the home, in businesses, and in safety-critical settings. In response, languages are being defined with support for new domains and complex computational abstractions. The need for formal techniques to help better understand the languages we use, correctly design new language abstractions, and reason about the behavior and correctness of programs is now more urgent then ever. In this dissertation we focus on research in programming language semantics and program analysis, aimed at building and reasoning about programming languages and applications. In language semantics, we first show how to use formal techniques during language design, presenting definitional techniques for object-oriented languages with concurrency features, including the Beta language and a paradigmatic language called KOOL. Since reuse is important, we then present a module system for K, a formalism for language definition that takes advantage of the strengths of rewriting logic and term rewriting techniques. Although currently specific to K, parts of this module system are also aimed at other formalisms, with the goal of providing a reuse mechanism for different forms of modular semantics in the future. Finally, since performance is also important, we show techniques for improving the executable and analysis performance of rewriting logic semantics definitions, specifically focused on decisions around the representation of program values and configurations used in semantics definitions. The work on performance, with a discussion of analysis performance, provides a good bridge to the second major topic, program analysis. We present a new technique aimed at annotation-driven static analysis called policy frameworks. A policy framework consists of analysis domains, an analysis generic front-end, an analysis-generic abstract language semantics, and an abstract analysis semantics that defines the semantics of the domain and the annotation language. After illustrating the technique using SILF, a simple imperative language, we then describe a policy framework for C. To provide a real example of using this framework, we have defined a units of measurement policy for C. This policy allows both type and code annotations to be added to standard C programs, which are then used to generate modular analysis tasks checked using the CPF semantics in Maude.
@phdthesis{hills-2009-thesis,author={Hills, Mark},title={{A Modular Rewriting Approach to Language Design, Evolution and Analysis}},school={University of Illinois at Urbana-Champaign (UIUC)},month=dec,year={2009},}
To create reusable definitions of language features, isolated from changes to other features in the language, it is important that feature definitions be modular. This abstract introduces ongoing work on modularity features in K, an algebraic, rewriting logic based formalism for defining the semantics of programming languages.
@inproceedings{hills-rosu-2008-wadt,author={Hills, Mark and Ro\c{s}u, Grigore},title={{Towards a Module System for {K}}},booktitle={Proceedings of the 19th International Workshop Recent Trends in Algebraic Development Techniques (WADT 2008)},pages={187--205},series={Lecture Notes in Computer Science},volume={5486},publisher={Springer},year={2009},doi={10.1007/978-3-642-03429-9_13},}
Memory Representations in Rewriting Logic Semantics Definitions
Mark
Hills
In Proceedings of the 7th International Workshop on Rewriting Logic and its Applications (WRLA 2008), 2009
The executability of rewriting logic makes it a compelling environment for language design and experimentation; the ability to interpret programs directly in the language semantics develops assurance that definitions are correct and that language features work well together. However, this executability raises new questions about language semantics that don’t necessarily make sense with non-executable definitions. For instance, suddenly the performance of the semantics, not just language interpreters or compilers based on the semantics, can be important, and representations must be chosen carefully to ensure that executing programs directly in language definitions is still feasible. Unfortunately, many obvious representations common in other semantic formalisms can lead to poor performance, including those used to represent program memory. This paper describes two different memory representations designed to improve performance: the first, which has been fully developed, is designed for use in imperative programs, while the second, still being developed, is intended for use in a variety of languages, with a special focus on pure object-oriented languages. Each representation is described and compared to the initial representation used in the language semantics, with thoughts on reuse also presented.
@inproceedings{hills-2008-wrla,author={Hills, Mark},booktitle={Proceedings of the 7th International Workshop on Rewriting Logic and its Applications (WRLA 2008)},title={{Memory Representations in Rewriting Logic Semantics Definitions}},publisher={Elsevier},series={Electronic Notes in Theoretical Computer Science},volume={238},number={3},pages={155--172},year={2009},doi={10.1016/j.entcs.2009.05.018},}
2007
On Formal Analysis of OO Languages Using Rewriting Logic: Designing for Performance
Rewriting logic provides a powerful, flexible mechanism for language definition and analysis. This flexibility in design can lead to problems during analysis, as different designs for the same language feature can cause drastic differences in analysis performance. This paper describes some of these design decisions in the context of KOOL, a concurrent, dynamic, object-oriented language. Also described is a general mechanism used in KOOL to support model checking while still allowing for ongoing, sometimes major, changes to the language definition.
@inproceedings{hills-rosu-2007-fmoods,author={Hills, Mark and Rosu, Grigore},title={{On Formal Analysis of {OO} Languages Using Rewriting Logic: Designing for Performance}},booktitle={Proceedings of the 9th IFIP WG 6.1 International Conference on Formal Methods for Open Object-Based Distributed Systems (FMOODS 2007)},pages={107--121},series={Lecture Notes in Computer Science},volume={4468},publisher={Springer},year={2007},doi={10.1007/978-3-540-72952-5_7},}
A Rewriting Approach to the Design and Evolution of Object-Oriented Languages
@inproceedings{hills-rosu-2007-oopsla,author={Hills, Mark and Rosu, Grigore},title={{A Rewriting Approach to the Design and Evolution of Object-Oriented Languages}},booktitle={Companion to the 22nd ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages, And Applications (OOPSLA 2007 Companion)},pages={827--828},publisher={ACM},year={2007},doi={10.1145/1297846.1297908},}
KOOL: An Application of Rewriting Logic to Language Prototyping and Analysis
This paper presents KOOL, a concurrent, dynamic, object-oriented language defined in rewriting logic. KOOL has been designed as an experimental language, with a focus on making the language easy to extend. This is done by taking advantage of the flexibility provided by rewriting logic, which allows for the rapid prototyping of new language features. An example of this process is illustrated by sketching the addition of synchronized methods. KOOL also provides support for program analysis through language extensions and the underlying capabilities of rewriting logic. This support is illustrated with several examples.
@inproceedings{hills-rosu-2007-rta,author={Hills, Mark and Rosu, Grigore},title={{KOOL: An Application of Rewriting Logic to Language Prototyping and Analysis}},booktitle={Proceedings of the 18th International Conference on Term Rewriting and Applications (RTA 2007)},pages={246--256},series={Lecture Notes in Computer Science},volume={4533},publisher={Springer},year={2007},doi={10.1007/978-3-540-73449-9_19},}
A Rewrite Framework for Language Definitions and for Generation of Efficient Interpreters
Mark
Hills, Traian Florin
Şerbănuţă, and Grigore
Roşu
In Proceedings of the 6th International Workshop on Rewriting Logic and its Applications (WRLA 2006), Jul 2007
A rewrite logic semantic definitional framework for programming languages is introduced, called K, together with partially automated translations of K language definitions into rewriting logic and into C. The framework is exemplified by defining SILF, a simple imperative language with functions. The translation of K definitions into rewriting logic enables the use of the various analysis tools developed for rewrite logic specifications, while the translation into C allows for very efficient interpreters. A suite of tests show the performance of interpreters compiled from K definitions.
@inproceedings{hills-serbanuta-rosu-2006-wrla,title={{A Rewrite Framework for Language Definitions and for Generation of Efficient Interpreters}},author={Hills, Mark and {\c S}erb{\u a}nu{\c t}{\u a}, Traian Florin and Ro{\c s}u, Grigore},booktitle={Proceedings of the 6th International Workshop on Rewriting Logic and its Applications (WRLA 2006)},publisher={Elsevier},series={Electronic Notes in Theoretical Computer Science},year={2007},volume={176},issue={4},month=jul,pages={215--231},doi={10.1016/j.entcs.2007.06.017},}
2004
An Orchestration Language for Parallel Objects
L.V.
Kalé, Mark
Hills, and Chao
Huang
In Proceedings of Seventh Workshop on Languages, Compilers, and Run-time Support for Scalable Systems (LCR 2004), 2004
Charm++, a parallel object language based on the idea of virtual processors, has attained significant success in efficient parallelization of applications. Requiring the user to only decompose the computation into a large number of objects ("virtual processors"), Charm++ empowers its intelligent adaptive runtime system to assign and reassign the objects to processors at runtime. This facility is used to optimize execution, including dynamic load balancing. However, in complex applications, Charm++ programs obscure the overall flow of control: one must look at the code of multiple objects to discern how the sets of objects are orchestrated in a given application. In this paper, we present an orchestration notation that allows expression of Charm++ functionality without its fragmented flow of control.
@inproceedings{kale-hills-huang-2004-lcr,author={Kalé, L.V. and Hills, Mark and Huang, Chao},title={{An Orchestration Language for Parallel Objects}},booktitle={Proceedings of Seventh Workshop on Languages, Compilers, and Run-time Support for Scalable Systems (LCR 2004)},pages={1--6},publisher={ACM},year={2004},doi={10.1145/1066650.1066658},}