Publications

2025

1. TLA+ for All: Model Checking in a Python Notebook

   Konstantin Läufer, and George K. Thiruvathukal

   May 2025

   To be presented at the TLA+ Community Meeting 2025

   Abs DOI Bib Code

   TLA+ is widely recognized for its effectiveness in specifying and verifying concurrent and distributed systems. However, for educators and practitioners, barriers to adoption include installation complexity and tooling setup. In the proposed presentation, we demonstrate a lightweight, easily shareable, and fully reproducible approach to running TLA+ in a Python notebook hosted on Google Colab without requiring new tools or custom Jupyter kernel development. By creating an environment where attendees can experiment with TLA+ models instantly during the presentation, we lower these barriers and demonstrate the suitability for education and outreach.

   @misc{Laufer_TLANotebook_2025,
     address = {Hamilton, Ontario, Canada},
     author = {Läufer, Konstantin and Thiruvathukal, George K.},
     code = {https://colab.research.google.com/drive/1c3YccNdvV73wSWcz-3h6-NQFvJYIdn0V},
     doi = {10.6084/m9.figshare.28376276.v1},
     month = may,
     note = {To be presented at the {TLA}+ {Community} {Meeting} 2025},
     title = {{TLA}+ for {All}: {Model} {Checking} in a {Python} {Notebook}},
     year = {2025}
   }

2024

1. FIE

   WIP: An Engaging Undergraduate Intro to Model Checking in Software Engineering Using TLA+

   Konstantin Läufer, Gunda Mertin, and George K. Thiruvathukal

   In Proceedings of the 2024 IEEE Frontiers in Education Conference (FIE), Oct 2024

   Abs DOI arXiv Bib PDF Code Slides Website

   Background: In this paper, we present our initial efforts to integrate formal methods, with a focus on model-checking specifications written in Temporal Logic of Actions (TLA+), into computer science education, targeting undergraduate juniors/seniors and graduate students. Formal methods can play a key role in ensuring correct behavior of safety-critical systems, yet remain underutilized in educational and industry contexts. Aims: We aim to (1) qualitatively assess the state of formal methods in computer science programs, (2) construct level-appropriate examples that could be included midway into one’s undergraduate studies, (3) demonstrate how to address successive "failures" through progressively stringent safety and liveness requirements, and (4) establish an ongoing framework for assessing interest and relevance among students. Methods: After starting with a refresher on mathematical logic, students specify the rules of simple puzzles in TLA+ and use its included model checker (known as TLC) to find a solution. We gradually escalate to more complex, dynamic, event-driven systems, such as the control logic of a microwave oven, where students will study safety and liveness requirements. We subsequently discuss explicit concurrency, along with thread safety and deadlock avoidance, by modeling bounded counters and buffers. Results: Our initial findings suggest that through careful curricular design and choice of examples and tools, it is possible to inspire and cultivate a new generation of software engineers proficient in formal methods. Conclusions: Our initial efforts suggest that 84% of our students had a positive experience in our formal methods course. Future plans include a longitudinal analysis within our own institution and proposals to partner with other institutions to explore the effectiveness of our open-source and open-access modules.

   @inproceedings{Laufer_FIE_2024,
     abbr = {FIE},
     address = {Washington, DC, USA},
     arxiv = {2407.21152},
     author = {Läufer, Konstantin and Mertin, Gunda and Thiruvathukal, George K.},
     booktitle = {Proceedings of the 2024 {IEEE} {Frontiers} in {Education} {Conference} ({FIE})},
     code = {https://colab.research.google.com/drive/1c3YccNdvV73wSWcz-3h6-NQFvJYIdn0V},
     doi = {10.1109/FIE61694.2024.10893422},
     month = oct,
     pdf = {https://figshare.com/ndownloader/files/49786386},
     publisher = {IEEE},
     slides = {https://figshare.com/ndownloader/files/49786365},
     title = {{WIP}: {An} {Engaging} {Undergraduate} {Intro} to {Model} {Checking} in {Software} {Engineering} {Using} {TLA}+},
     url = {https://arxiv.org/abs/2407.21152},
     website = {https://lucformalmethodscourse.github.io},
     year = {2024}
   }

2. Computer

   Engaging More Students in Formal Methods Education: A Practical Approach Using Temporal Logic of Actions

   Konstantin Läufer, Gunda Mertin, and George K. Thiruvathukal

   Computer, Dec 2024

   Abs DOI Bib PDF Code Slides Website

   Our hands-on course introduces model checking using Temporal Logic of Actions through practical examples like the control logic for a microwave oven. Due to highly positive initial feedback from our own students, we plan to broaden our reach by partnering with other institutions.

   @article{Laufer_IEEEComputer_2024,
     abbr = {Computer},
     author = {Läufer, Konstantin and Mertin, Gunda and Thiruvathukal, George K.},
     code = {https://colab.research.google.com/drive/1c3YccNdvV73wSWcz-3h6-NQFvJYIdn0V},
     doi = {10.1109/MC.2024.3462188},
     journal = {Computer},
     month = dec,
     number = {12},
     pdf = {https://figshare.com/ndownloader/files/49786386},
     slides = {https://figshare.com/ndownloader/files/49786365},
     title = {Engaging {More} {Students} in {Formal} {Methods} {Education}: {A} {Practical} {Approach} {Using} {Temporal} {Logic} of {Actions}},
     volume = {57},
     website = {https://lucformalmethodscourse.github.io},
     year = {2024}
   }

3. Can Large-Language Models Help us Better Understand and Teach the Development of Energy-Efficient Software?

   Ryan Hasler, Konstantin Läufer, George K. Thiruvathukal, and 5 more authors

   Oct 2024

   Abs arXiv Bib PDF

   Computing systems are consuming an increasing and unsustainable fraction of society’s energy footprint, notably in data centers. Meanwhile, energy-efficient software engineering techniques are often absent from undergraduate curricula. We propose to develop a learning module for energy-efficient software, suitable for incorporation into an undergraduate software engineering class. There is one major problem with such an endeavor: undergraduate curricula have limited space for mastering energy-related systems programming aspects. To address this problem, we propose to leverage the domain expertise afforded by large language models (LLMs). In our preliminary studies, we observe that LLMs can generate energy-efficient variations of basic linear algebra codes tailored to both ARM64 and AMD64 architectures, as well as unit tests and energy measurement harnesses. On toy examples suitable for classroom use, this approach reduces energy expenditure by 30-90%. These initial experiences give rise to our vision of LLM-based meta-compilers as a tool for students to transform high-level algorithms into efficient, hardware-specific implementations. Complementing this tooling, we will incorporate systems thinking concepts into the learning module so that students can reason both locally and globally about the effects of energy optimizations.

   @misc{Hasler_LLMENERGY_2024,
     arxiv = {2411.08912},
     author = {Hasler, Ryan and Läufer, Konstantin and Thiruvathukal, George K. and Peng, Huiyun and Robinson, Kyle and Davis, Kirsten and Lu, Yung-Hsiang and Davis, James C.},
     month = oct,
     pdf = {https://arxiv.org/pdf/2411.08912},
     publisher = {arxiv},
     title = {Can {Large}-{Language} {Models} {Help} us {Better} {Understand} and {Teach} the {Development} of {Energy}-{Efficient} {Software}?},
     url = {https://arxiv.org/abs/2411.08912},
     year = {2024}
   }

4. Large Language Models for Energy-Efficient Code: Emerging Results and Future Directions

   Huiyun Peng, Arjun Gupte, Nicholas John Eliopoulos, and 8 more authors

   Oct 2024

   Abs arXiv Bib PDF

   Energy-efficient software helps improve mobile device experiences and reduce the carbon footprint of data centers. However, energy goals are often de-prioritized in order to meet other requirements. We take inspiration from recent work exploring the use of large language models (LLMs) for different software engineering activities. We propose a novel application of LLMs: as code optimizers for energy efficiency. We describe and evaluate a prototype, finding that over 6 small programs our system can improve energy efficiency in 3 of them, up to 2x better than compiler optimizations alone. From our experience, we identify some of the challenges of energy-efficient LLM code optimization and propose a research agenda.

   @misc{Peng_LLMEnergy_2024,
     arxiv = {2410.09241},
     author = {Peng, Huiyun and Gupte, Arjun and Eliopoulos, Nicholas John and Ho, Chien Chou and Mantri, Rishi and Deng, Leo and Jiang, Wenxin and Lu, Yung-Hsiang and Läufer, Konstantin and Thiruvathukal, George K. and Davis, James C.},
     month = oct,
     pdf = {https://arxiv.org/pdf/2410.09241},
     title = {Large {Language} {Models} for {Energy}-{Efficient} {Code}: {Emerging} {Results} and {Future} {Directions}},
     url = {https://arxiv.org/abs/2410.09241},
     year = {2024}
   }

2023

1. eScience

   UnoAPI: Modern Techniques for Engineering High-Performance Software (Tutorial)

   Konstantin Läufer, and George K. Thiruvathukal

   Oct 2023

   Presented at the IEEE eScience Conference

   Abs Bib Code Website

   One of the key goals in high-performance and distributed software engineering is to leverage the specific capabilities of the target hardware to the extent possible. Today’s systems are typically heterogeneous, where one or more architectures may be present within a single system, such as conventional CPU cores combined with accelerators such as GPUs and FPGAs. Although parallel computing itself has reached a high level of maturity, as we move toward exascale and beyond computing, challenges similar to those that plagued the earliest days of parallel and distributed computing are beginning to resurface: Leveraging heterogeneity while balancing performance, software portability, and developer productivity (P3). This tutorial provides hands-on experience in developing high-performance and embedded software for heterogeneous architectures using Intel’s oneAPI reference implementation of the Khronos SYCL standard in conjunction with state-of-the-art software engineering methods. By raising the abstraction level via its unified application programming interface (API), oneAPI makes it easier to develop portable high-performance software for systems with embedded hardware accelerators, such as GPUs and FPGAs.

   @misc{Laufer_escience_2023,
     abbr = {eScience},
     address = {Limmasol, Cyprus},
     author = {Läufer, Konstantin and Thiruvathukal, George K.},
     code = {https://github.com/LoyolaChicagoCode/unoapi-dpcpp-examples},
     month = oct,
     note = {Presented at the {IEEE} {eScience} {Conference}},
     title = {{UnoAPI}: {Modern} {Techniques} for {Engineering} {High}-{Performance} {Software} ({Tutorial})},
     url = {https://www.escience-conference.org/2023/tutorials/unoapi},
     website = {https://unoapi.org},
     year = {2023}
   }

2. New technologies as decision aids for the advancement of ecological risk assessment

   Federico Sinche Chele, Priscilla Jimenez‐Pazmino, and Konstantin Läufer

   Integrated Environmental Assessment and Management, Aug 2023

   Abs DOI Bib PDF Website

   Moore’s law states that the number of transistors that can be placed on an integrated circuit doubles every two years (Moore, 1975). This has led to a steady increase in the processing power of computers over time, and technology is now enhancing and advancing software and scientific applications, which has enabled computationally intensive methods such as machine learning, data science, modeling, and simulation. The advancement of computers and data-driven algorithms is profoundly impacting people’s lives. It is changing the way we work, the way we learn, and the way we interact with the world around us. Here, this editorial will discuss how scientists can benefit from the latest technology advancements and related tools by incorporating them into the ecological risk assessment (ERA) to study ecosystems as a way to create refined assessments and accelerate the turnaround times.

   @article{Sinche_OSTI_2023,
     author = {Chele, Federico Sinche and Jimenez‐Pazmino, Priscilla and Läufer, Konstantin},
     doi = {10.1002/ieam.4815},
     journal = {Integrated Environmental Assessment and Management},
     month = aug,
     number = {5},
     pdf = {https://www.osti.gov/servlets/purl/2000330},
     title = {New technologies as decision aids for the advancement of ecological risk assessment},
     url = {https://www.osti.gov/biblio/2000330},
     volume = {19},
     website = {https://www.osti.gov/biblio/2000330},
     year = {2023}
   }

2022

1. TCPP

   UnoAPI: Balancing Performance, Portability, and Productivity (P3) in HPC Education

   Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the Workshop on Education for High-Performance Computing (EduHPC-22), Nov 2022

   Held in conjunction with SC22

   Abs DOI Bib PDF Code Slides Website

   Abstract—oneAPI is a major initiative by Intel aimed at making it easier to program heterogeneous architectures used in high-performance computing using a unified application programming interface (API). While raising the abstraction level via a unified API represents a promising step for the current generation of students and practitioners to embrace highperformance computing, we argue that a curriculum of welldeveloped software engineering methods and well-crafted exemplars will be necessary to ensure interest by this audience and those who teach them. We aim to bridge the gap by developing a curriculum—codenamed UnoAPI—that takes a more holistic approach by looking beyond language and framework to include the broader development ecosystem, similar to the experience found in popular HPC languages such as Python. We hope to make parallel programming a more attractive option by making it look more like general application development in modern languages being used by most students and educators today. Our curriculum emanates from the perspective of well-crafted exemplars from the foundations of computer systems—given that most HPC architectures of interest begin from the systems tradition—with an integrated treatment of essential principles of distributed systems, programming languages, and software engineering. We argue that a curriculum should cover the essence of these topics to attract students to HPC and enable them to confidently solve computational problems using oneAPI. By the time of this submission, we have shared our materials with a small group of undergraduate sophomores, and their responses have been encouraging in terms of self-reported comprehension and ability to reproduce the compilation and execution of exemplars on their personal systems. We plan a follow-up study with a larger cohort by incorporating some of our materials in our existing course on High-Performance Computing.

   @inproceedings{Laufer_EduHPC_2022,
     abbr = {TCPP},
     address = {Dallas, TX, USA},
     author = {Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {Workshop} on {Education} for {High}-{Performance} {Computing} ({EduHPC}-22)},
     code = {https://github.com/LoyolaChicagoCode/unoapi-dpcpp-examples},
     doi = {10.6084/m9.figshare.21200464.v3},
     month = nov,
     note = {Held in conjunction with SC22},
     pdf = {https://figshare.com/ndownloader/files/37586422},
     publisher = {IEEE},
     slides = {https://figshare.com/ndownloader/files/38208480},
     title = {{UnoAPI}: {Balancing} {Performance}, {Portability}, and {Productivity} ({P3}) in {HPC} {Education}},
     url = {https://ecommons.luc.edu/cs_facpubs/314/},
     website = {https://unoapi.org},
     year = {2022}
   }

2. ASE

   Snapshot Metrics Are Not Enough: Analyzing Software Repositories with Longitudinal Metrics (Tool Demonstration)

   Nicholas Synovic, Matt Hyatt, Rohan Sethi, and 11 more authors

   In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering (ASE ’23), Oct 2022

   Abs DOI Bib PDF Video Code

   Software metrics capture information about software development products and processes. These metrics support decision-making, e.g., in team management or dependency selection. However, existing metrics tools measure only a snapshot of a software project. Little attention has been given to enabling engineers to reason about metric trends over time—longitudinal metrics that give insight about process, not just product. In this work, we present PRIME (PRocess Internal MEtrics), a tool for computing and visualizing process metrics. The currently-supported metrics include productivity, issue density, issue spoilage, and bus factor. We illustrate the value of longitudinal data and conclude with a research agenda.

   @inproceedings{Synovic_ASE_2022,
     abbr = {ASE},
     address = {Ann Arbor, MI, USA},
     author = {Synovic, Nicholas and Hyatt, Matt and Sethi, Rohan and Thota, Sohini and {Shilpika} and Miller, Allan J. and Jiang, Wenxin and Amobi, Emmanuel S. and Pinderski, Austin and Läufer, Konstantin and Hayward, Nicholas J. and Klingensmith, Neil and Davis, James C. and Thiruvathukal, George K.},
     booktitle = {Proceedings of the 37th {IEEE}/{ACM} {International} {Conference} on {Automated} {Software} {Engineering} ({ASE} '23)},
     code = {https://github.com/SoftwareSystemsLaboratory/prime},
     doi = {10.1145/3551349.3559517},
     month = oct,
     pdf = {https://ecommons.luc.edu/cs_facpubs/296/},
     publisher = {Association for Computing Machinery},
     title = {Snapshot {Metrics} {Are} {Not} {Enough}: {Analyzing} {Software} {Repositories} with {Longitudinal} {Metrics} ({Tool} {Demonstration})},
     url = {https://ecommons.luc.edu/cs_facpubs/296/},
     video = {https://youtu.be/YigEHy3\_JCo},
     year = {2022}
   }

3. LUC

   DriveAware: Generating Actionable Data through Vehicle-Based Citizen Science (Poster)

   Álvaro Landaluce, Federico Sinche Chele, Loretta Stalans, and 2 more authors

   May 2022

   Presented at the Loyola Computer Science Research Symposium

   Abs Bib PDF

   As we’re driving around Chicago going about our weekly business, we can’t help but notice telltale signs of social problems in our neighborhoods, such as homelessness, drug use, street prostitution, and suspected human trafficking. Some neighborhoods are frozen in time, often with little evidence of new development and access to opportunities that are clustered around the north side of Chicago. It may not be comfortable for us to intervene directly or scientifically sound to draw conclusions based on our isolated observations. Nevertheless, we may have an opportunity to contribute as citizen scientists by recording our observations and sharing them with better-equipped stakeholders. The interdisciplinary DriveAware project aims to use mobile computing technology to make it safe and convenient for citizen scientists in their vehicles or on foot to augment existing observations, e.g. Google Street View, such as geotagged annotated images, to various stakeholders, such as social scientists, law enforcement, social service providers, and ordinary fellow citizens. The collected data can be used in various ways, including offline data analysis and real-time maps and dashboards, as well as concrete action, such as social scientists going on location to interview the affected individuals, law enforcement investigating and prosecuting potential incidents, and social service providers intervening directly, e.g., by picking up homeless persons during a cold spell and taking them to shelters. In addition to the interdisciplinary stakeholders’ existing research questions, this project gives rise to various computer science research questions, such as system requirements and architecture, system implementation, integration with existing databases in particular fields, user experience studies to determine the likelihood of reporting observations through in-car voice-based and/or reduced distraction touch interfaces (Android Auto/Apple CarPlay) versus conventional mobile apps. To support our research questions, we have developed a proof of concept of a mobile application for reporting observations in various pertinent categories, which get stored in a cloud-hosted Firebase (NoSQL) instance and can be accessed through a Python Jupyter notebook and analyzed/visualized in multidimensional ways. Future plans include integration with commercial automotive frameworks, such as Android Auto (and eventually Apple CarPlay) and automatic image collection from dashcams connected to the mobile phone via Bluetooth. The diagram below illustrates the high-level system architecture.

   @misc{DeLandaluce_DriveAware_2022,
     abbr = {LUC},
     address = {Loyola University Chicago},
     author = {de Landaluce, Álvaro and Sinche Chele, Federico and Stalans, Loretta and Thiruvathukal, George K. and Läufer, Konstantin},
     month = may,
     note = {Presented at the {Loyola} {Computer} {Science} {Research} {Symposium}},
     pdf = {https://ecommons.luc.edu/csrs/ay2021-2022/techreport/1/},
     title = {{DriveAware}: {Generating} {Actionable} {Data} through {Vehicle}-{Based} {Citizen} {Science} ({Poster})},
     url = {https://ecommons.luc.edu/csrs/ay2021-2022/techreport/1/},
     year = {2022}
   }

2021

1. Learning Test-Driven Development

   Saleem Siddiqui

   May 2021

   Bib HTML Website

   @misc{SaleemSiddiqui_2021,
     author = {Siddiqui, Saleem},
     howpublished = {Foreword by Konstantin Läufer},
     html = {https://learning.oreilly.com/library/view/learning-test-driven-development/9781098106461/foreword01.html},
     publisher = {O'Reilly Media, Inc.},
     title = {Learning {Test}-{Driven} {Development}},
     url = {https://learning.oreilly.com/library/view/learning-test-driven-development/9781098106461/foreword01.html},
     website = {https://learning.oreilly.com/library/view/learning-test-driven-development/9781098106461/foreword01.html},
     year = {2021}
   }

2. LUC

   Metrics Pipeline (Codename): An Analytics and Visualization Pipeline for Software Quality Metrics (Poster)

   Nicholas Synovic, Emmanuel Amobi, Erik Greve, and 8 more authors

   Apr 2021

   Presented at the Loyola Undergraduate Research and Engagement Symposium

   Abs Bib PDF

   The Metrics Pipeline (Codename) focuses on metrics indicative of team progress and project health instead of privileging individual metrics, e.g. number of commits, etc. The Metrics Dashboard allows the user to submit the URL of a hosted repository for batch analysis, whose results are then cached. Upon completion, the user can interactively study various metrics over time (at varying granularity), numerically, and visually. The initial version of the system is up and running as a public cloud service (SaaS) and supports project size (KLOC), defect density, defect spoilage, and productivity. While our system is by no means the first to support software metrics, we believe it may be one of the first community-focused extensible resources that can be used by any hosted project.

   @misc{Synovic_URES_2021,
     abbr = {LUC},
     address = {Loyola University Chicago},
     author = {Synovic, Nicholas and Amobi, Emmanuel and Greve, Erik and Von Hatten, Sophie and Pinderski, Austin and Rodriguez, Stephanie and Zugschwert, Martin and Davis, Jamie C. and Hayward, Nicholas and Läufer, Konstantin and Thiruvathukal, George K.},
     month = apr,
     note = {Presented at the {Loyola} {Undergraduate} {Research} and {Engagement} {Symposium}},
     pdf = {https://ecommons.luc.edu/ures/2021/2021/91/},
     title = {Metrics {Pipeline} ({Codename}): {An} {Analytics} and {Visualization} {Pipeline} for {Software} {Quality} {Metrics} ({Poster})},
     url = {https://ecommons.luc.edu/ures/2021/2021/91/},
     year = {2021}
   }

2020

1. LUC

   Toward a containerized pipeline for longitudinal analysis of open-source software projects (Poster)

   Allan Miller, George K. Thiruvathukal, Konstantin Läufer, and 10 more authors

   Apr 2020

   Presented at the Loyola Graduate Research Symposium

   Abs Bib PDF

   Trust in open-source software is a cornerstone of scientific progress and a foundation of high-quality public services. Just as standards are integral when judging the efficacy of a novel pharmaceutical compound or determining the spread of a new disease, the software used to make those determinations should be useful, error-free, reliable, performant, and secure. A small bug in an application, library, or framework can lead to economic loss and even loss of life. We rely on software developers to be dynamic and responsive to user review and bug-reporting. Our team developed an open-source modular pipeline to perform empirical investigations of software quality. A key innovation of our approach is to look at projects “from a distance” similar to methods used in climate, e.g. satellite images being used to observe environmental impacts in air quality/rain forests. Instead of looking at language-specific source code features, our pipeline uses a language-agnostic high-level approach to track software quality by focusing on the development process itself, which yields great insight into the processes programmers use to write and maintain their software. Our distributed modular approach to analytics allows the pipeline to be easily extended to support additional metrics in future work. We store extracted data in an embedded SQLite database, which means that analysis can proceed without complex server setup, let alone hosting the software on dedicated servers. Our analytical modules are designed for efficiency, and future runs of our software only collect missing data, supporting the incremental analysis of known, important open-source projects.

   @misc{Miller_GRS_2020,
     abbr = {LUC},
     address = {Loyola University Chicago},
     author = {Miller, Allan and Thiruvathukal, George K. and Läufer, Konstantin and Amobi, Emmanuel and Higgins, Sean and Maliakal, Linette and Meister, Emily and Putter, Jean-Luc and Rose, Alex and Synovic, Nicholas and Von Hatten, Sophie and Warkentin, Jonathan and Zugschwert, Martin},
     month = apr,
     note = {Presented at the {Loyola} {Graduate} {Research} {Symposium}},
     pdf = {https://ecommons.luc.edu/grs/2020/posters/4},
     title = {Toward a containerized pipeline for longitudinal analysis of open-source software projects ({Poster})},
     url = {https://ecommons.luc.edu/grs/2020/posters/4},
     year = {2020}
   }

2019

1. Scala

   Tests as Maintainable Assets via Auto-Generated Spies: A Case Study Involving the Scala Collections Library’s Iterator Trait

   Konstantin Läufer, John O’Sullivan, and George K. Thiruvathukal

   In Proceedings of the Tenth ACM SIGPLAN Symposium on Scala (Scala ’19), Jul 2019

   Abs DOI arXiv Bib PDF Code Website

   In testing stateful abstractions, it is often necessary to record interactions, such as method invocations, and express assertions over these interactions. Following the Test Spy design pattern, we can reify such interactions programmatically through additional mutable state. Alternatively, a mocking framework, such as Mockito, can automatically generate test spies that allow us to record the interactions and express our expectations in a declarative domain-specific language. According to our study of the test code for Scala’s Iterator trait, the latter approach can lead to a significant reduction of test code complexity in terms of metrics such as code size (in some cases over 70% smaller), cyclomatic complexity, and amount of additional mutable state required. In this tools paper, we argue that the resulting test code is not only more maintainable, readable, and intentional, but also a better stylistic match for the Scala community than manually implemented, explicitly stateful test spies.

   @inproceedings{Laufer_Scala_2019,
     abbr = {Scala},
     address = {London, United Kingdom},
     arxiv = {1808.09630},
     author = {Läufer, Konstantin and O'Sullivan, John and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {Tenth} {ACM} {SIGPLAN} {Symposium} on {Scala} ({Scala} '19)},
     code = {https://github.com/klaeufer/issue10709-scala},
     doi = {10.1145/3337932.3338814},
     keywords = {automated unit testing, iterator design pattern, mock-based testing, prefix sum, spy-based testing, stream processing, test code complexity, test code metrics},
     month = jul,
     pages = {17--21},
     pdf = {https://arxiv.org/pdf/1808.09630},
     publisher = {Association for Computing Machinery},
     title = {Tests as {Maintainable} {Assets} via {Auto}-{Generated} {Spies}: {A} {Case} {Study} {Involving} the {Scala} {Collections} {Library}'s {Iterator} {Trait}},
     url = {https://2019.ecoop.org/details/scala-2019-papers/6/Tests-as-Maintainable-Assets-Via-Auto-generated-Spies},
     website = {https://2019.ecoop.org/details/scala-2019-papers/6/Tests-as-Maintainable-Assets-Via-Auto-generated-Spies},
     year = {2019}
   }

2018

1. TCPP

   Managing Concurrency in Mobile User Interfaces with Examples in Android

   Konstantin Läufer, and George K. Thiruvathukal

   In Topics in Parallel and Distributed Computing, Sep 2018

   Abs DOI arXiv Bib PDF Code Website

   In this chapter, we explore various parallel and distributed computing topics from a user-centric software engineering perspective. Specifically, in the context of mobile application development, we study the basic building blocks of interactive applications in the form of events, timers, and asynchronous activities, along with related software modeling, architecture, and design topics.

   @incollection{Laufer_CDERBook_2018,
     abbr = {TCPP},
     arxiv = {1705.02899},
     author = {Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Topics in {Parallel} and {Distributed} {Computing}},
     code = {https://github.com/lucoodevcourse},
     doi = {10.1007/978-3-319-93109-8_9},
     editor = {Prasad, Sushil K. and Gupta, Anshul and Rosenberg, Arnold and Sussman, Alan and Weems, Charles},
     month = sep,
     pdf = {https://arxiv.org/pdf/1705.02899},
     publisher = {Springer},
     title = {Managing {Concurrency} in {Mobile} {User} {Interfaces} with {Examples} in {Android}},
     url = {https://arxiv.org/abs/1705.02899},
     website = {https://lucoodevcourse.github.io},
     year = {2018}
   }

2. Metrics Dashboard: A Hosted Platform for Software Quality Metrics

   George K. Thiruvathukal,  Shilpika, Nicholas J. Hayward, and 1 more author

   Apr 2018

   Technical Report

   Abs arXiv Bib PDF

   There is an emerging consensus in the scientific software community that progress in scientific research is dependent on the "quality and accessibility of software at all levels" (this http URL). This progress depends on embracing the best traditional—and emergent—practices in software engineering, especially agile practices that intersect with the more formal tradition of software engineering. As a first step in our larger exploratory project to study in-process quality metrics for software development projects in Computational Science and Engineering (CSE), we have developed the Metrics Dashboard, a platform for producing and observing metrics by mining open-source software repositories on GitHub. Unlike GitHub and similar systems that provide individual performance metrics (e.g. commits), the Metrics Dashboard focuses on metrics indicative of team progress and project health. The Metrics Dashboard allows the user to submit the URL of a hosted repository for batch analysis, whose results are then cached. Upon completion, the user can interactively study various metrics over time (at varying granularity), numerically and visually. The initial version of the system is up and running as a public cloud service (SaaS) and supports project size (KLOC), defect density, defect spoilage, and productivity. While our system is by no means the first to support software metrics, we believe it may be one of the first community-focused extensible resources that can be used by any hosted project.

   @techreport{Thiruvathukal_MetricsDashboard_2018,
     arxiv = {1804.02053},
     author = {Thiruvathukal, George K. and {Shilpika} and Hayward, Nicholas J. and Läufer, Konstantin},
     institution = {Loyola University Chicago},
     month = apr,
     note = {Technical {Report}},
     pdf = {https://arxiv.org/pdf/1804.02053},
     timestamp = {Mon, 13 Aug 2018 16:47:28 +0200},
     title = {Metrics {Dashboard}: {A} {Hosted} {Platform} for {Software} {Quality} {Metrics}},
     url = {https://arxiv.org/abs/1804.02053},
     year = {2018}
   }

2017

1. Experiences with Scala Across the College-Level Curriculum (Invited Talk)

   Mark Lewis, Konstantin Läufer, and George K. Thiruvathukal

   May 2017

   Presented at Scala Days, GOTO Conferences

   Bib Slides Website

   @misc{Lewis_ScalaDays_2017,
     address = {Chicago, IL, USA},
     author = {Lewis, Mark and Läufer, Konstantin and Thiruvathukal, George K.},
     month = may,
     note = {Presented at {Scala} {Days}, {GOTO} {Conferences}},
     slides = {https://docs.google.com/presentation/d/1bRLxAcNxrtbOW8T0SUNs\_PdyCfKL9ZGhBIChXWgv29Q},
     title = {Experiences with {Scala} {Across} the {College}-{Level} {Curriculum} ({Invited} {Talk})},
     url = {https://docs.google.com/presentation/d/1bRLxAcNxrtbOW8T0SUNs_PdyCfKL9ZGhBIChXWgv29Q},
     website = {https://docs.google.com/presentation/d/1bRLxAcNxrtbOW8T0SUNs_PdyCfKL9ZGhBIChXWgv29Q},
     year = {2017}
   }

2016

1. EVB

   A Polyglot Approach to Bioinformatics Data Integration: A Phylogenetic Analysis of HIV-1

   Steven Reisman, Thomas Hatzopoulos, Konstantin Läufer, and 2 more authors

   Evolutionary Bioinformatics, May 2016

   Abs DOI Bib HTML PDF

   As sequencing technologies continue to drop in price and increase in throughput, new challenges emerge for the management and accessibility of genomic sequence data. We have developed a pipeline for facilitating the storage, retrieval, and subsequent analysis of molecular data, integrating both sequence and metadata. Taking a polyglot approach involving multiple languages, libraries, and persistence mechanisms, sequence data can be aggregated from publicly available and local repositories. Data are exposed in the form of a RESTful web service, formatted for easy querying, and retrieved for downstream analyses. As a proof of concept, we have developed a resource for annotated HIV-1 sequences. Phylogenetic analyses were conducted for ¿6,000 HIV-1 sequences revealing spatial and temporal factors influence the evolution of the individual genes uniquely. Nevertheless, signatures of origin can be extrapolated even despite increased globalization. The approach developed here can easily be customized for any species of interest.

   @article{doi:10.4137/EBO.S32757,
     abbr = {EVB},
     author = {Reisman, Steven and Hatzopoulos, Thomas and Läufer, Konstantin and Thiruvathukal, George K. and Putonti, Catherine},
     doi = {10.4137/EBO.S32757},
     html = {https://doi.org/10.4137/EBO.S32757},
     journal = {Evolutionary Bioinformatics},
     pdf = {https://journals.sagepub.com/doi/epub/10.4137/EBO.S32757},
     title = {A {Polyglot} {Approach} to {Bioinformatics} {Data} {Integration}: {A} {Phylogenetic} {Analysis} of {HIV}-1},
     volume = {12},
     year = {2016}
   }

2015

1. SIES

   A Framework Architecture for Student Learning in Distributed Embedded Systems

   William Honig, Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the 10th IEEE International Symposium on Industrial Embedded Systems (SIES 2015), Jun 2015

   Abs DOI Bib PDF

   Academic courses focused on individual microcomputers or client/server applications are no longer sufficient for students to develop knowledge in embedded systems. Current and near-term industrial systems employ multiple interacting components and new network and security approaches; hence, academic preparation requires teaching students to develop realistic projects comparable to these real-world products. However, the complexity, breadth, and technical variations of these real-world products are difficult to reproduce in the classroom. This paper outlines preliminary work on a framework architecture suitable for academic teaching of modern embedded systems including the Internet of Things. It defines four layers, two of which are at the edges of the network, and not adequately covered in academia. For each layer of the architecture, specific technology and suitable devices are identified. Desired academic outcomes for courses using projects based on the architecture are identified. Feedback and comparison is sought on how effective student course and research activities based on the framework will be to real-world embedded systems developers.

   @inproceedings{Honig_SIES_2015,
     abbr = {SIES},
     address = {Siegen, Germany},
     author = {Honig, William and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the 10th {IEEE} {International} {Symposium} on {Industrial} {Embedded} {Systems} ({SIES} 2015)},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/SIES.2015.7185052},
     month = jun,
     pages = {1--4},
     pdf = {https://ecommons.luc.edu/cs_facpubs/257/},
     publisher = {IEEE},
     title = {A {Framework} {Architecture} for {Student} {Learning} in {Distributed} {Embedded} {Systems}},
     url = {https://ecommons.luc.edu/cs_facpubs/257/},
     year = {2015}
   }

2. Middleware for Collaborative Distributed/Mobile Applications: XMPP or Reactive HTTP? (Poster)

   Brian Gathright, Konstantin Läufer, Aziz Parsa, and 1 more author

   May 2015

   Presented at the 4th Greater Chicago Area System Research Workshop (GCASR)

   Bib Website

   @misc{Gathright_GCASR_2015,
     address = {Chicago, IL, USA},
     author = {Gathright, Brian and Läufer, Konstantin and Parsa, Aziz and Thiruvathukal, George K.},
     month = may,
     note = {Presented at the 4th {Greater} {Chicago} {Area} {System} {Research} {Workshop} ({GCASR})},
     title = {Middleware for {Collaborative} {Distributed}/{Mobile} {Applications}: {XMPP} or {Reactive} {HTTP}? ({Poster})},
     url = {https://drive.google.com/file/d/0B8Bb5t8tHAw-bzY5blk4Q3U5ckE/view?resourcekey=0-ZCTtc5dJ5ke3QDj1d7Ct-Q},
     website = {https://drive.google.com/file/d/0B8Bb5t8tHAw-bzY5blk4Q3U5ckE/view?resourcekey=0-ZCTtc5dJ5ke3QDj1d7Ct-Q},
     year = {2015}
   }

3. Towards Sustainable Digital Humanities Software

   George K. Thiruvathukal,  Shilpika, Nicholas Hayward, and 2 more authors

   Nov 2015

   Presented at the Chicago Colloquium on Digital Humanities and Computer Science

   Abs Bib PDF

   Our work in software quality for digital humanities was borne of an effort to address sustainable practices in scientific software development, where the speaker (Thiruvathukal) co-authored a position paper on the case for software engineering in scientific software development as part of an all-encompassing strategy to create more sustainable scientific software (an example of a well-known scientific software package is LINPACK). In this position paper, we addressed how “progress in scientific research is dependent on the quality and accessibility of software at all levels". This progress depends on embracing the best traditional–and emergent–practices in software engineering, especially agile practices that intersect with the more formal tradition of software engineering. Although this paper was about scientific software development, it could just as easily have been about any interdisciplinary software development community. Our interest in applying what we’ve learned to DH, however, comes from work Thiruvathukal and Hayward have done and/or supervised in DH, especially WoolfOnline and a Richmond Times Dispatch viewer, where more software engineering could have been helpful.

   @misc{Thiruvathukal_CCDHCS_2015,
     address = {Chicago, IL, USA},
     author = {Thiruvathukal, George K. and {Shilpika} and Hayward, Nicholas and Aguiar, Saulo and Läufer, Konstantin},
     month = nov,
     note = {Presented at the {Chicago} {Colloquium} on {Digital} {Humanities} and {Computer} {Science}},
     pdf = {https://ecommons.luc.edu/cs_facpubs/126/},
     title = {Towards {Sustainable} {Digital} {Humanities} {Software}},
     url = {https://ecommons.luc.edu/cs_facpubs/126/},
     year = {2015}
   }

2014

1. SIGCSE

   Scala for Introductory CS and Parallelism (Workshop)

   Mark Lewis, Konstantin Läufer, and George K. Thiruvathukal

   Mar 2014

   Presented at the 45th ACM Technical Symposium on Computer Science Education (SIGCSE ’14)

   Abs Bib Website

   Scala is one of a new breed of hybrid languages with both object-oriented and functional aspects. It happens to be the most successful of these languages coming in at #12 on the Red Monk language ranking and leading all languages in their 2nd tier. This workshop will introduce participants to the Scala programming language, how it can be used effectively in introductory CS courses, and the parallel tools that are available for it. We begin with simple examples in the REPL and scripting environment, then look at doing larger, object-oriented projects. We finish off with an exploration of composable futures and the Akka actor library. Participants are strongly recommended to bring a laptop.

   @misc{Lewis_SIGCSE_2014,
     abbr = {SIGCSE},
     address = {Atlanta, GA, USA},
     author = {Lewis, Mark and Läufer, Konstantin and Thiruvathukal, George K.},
     month = mar,
     note = {Presented at the 45th {ACM} {Technical} {Symposium} on {Computer} {Science} {Education} ({SIGCSE} ’14)},
     title = {Scala for {Introductory} {CS} and {Parallelism} ({Workshop})},
     url = {http://scalaworkshop.cs.luc.edu/html},
     website = {http://scalaworkshop.cs.luc.edu/html},
     year = {2014}
   }

2013

1. TCPP

   Spring-11: Introducing PDC topics into CS1/2 and a Mobile- and Cloud-Based Intermediate Software Design Course

   Konstantin Läufer, Chandra Sekharan, George K. Thiruvathukal, and 1 more author

   In Proceedings of the 3rd NSF/IEEE-CS TCPP Workshop on Parallel and Distributed Computing Education (EduPar), May 2013

   Abs Bib Website

   In this brief update, we inform the TCPP Curriculum Committee of our continued efforts as early adopters. During 2011, we implemented seven three­week PDC course modules, each of which we incorporated into a different existing course, ranging from CS2 to advanced electives. During 2012, we have focused on pushing PDC topics further down into CS1 and CS2, fleshing out PDC coverage in our intermediate object­oriented development course (CS 313), and stepping up evaluation.

   @inproceedings{Laufer_EduPar_2013,
     abbr = {TCPP},
     address = {Boston, Massachusetts, USA},
     author = {Läufer, Konstantin and Sekharan, Chandra and Thiruvathukal, George K. and Kaylor, Joseph P.},
     booktitle = {Proceedings of the 3rd {NSF}/{IEEE}-{CS} {TCPP} {Workshop} on {Parallel} and {Distributed} {Computing} {Education} ({EduPar})},
     month = may,
     publisher = {IEEE},
     title = {Spring-11: {Introducing} {PDC} topics into {CS1}/2 and a {Mobile}- and {Cloud}-{Based} {Intermediate} {Software} {Design} {Course}},
     url = {https://tcpp.cs.gsu.edu/curriculum/?q=EduPar-13_Proceedings},
     website = {https://tcpp.cs.gsu.edu/curriculum/?q=EduPar-13_Proceedings},
     year = {2013}
   }

2. GCASR

   Building Capable, Energy-Efficient, Flexible Visualization and Sensing Clusters from Commodity Tablets (Poster)

   Thomas Delgado Dias, Xian Yan, Konstantin Läufer, and 1 more author

   May 2013

   Presented at the 2nd Greater Chicago Area System Research Workshop (GCASR)

   Bib PDF

   @misc{Dias_GCASR_2013,
     abbr = {GCASR},
     address = {Chicago, IL, USA},
     author = {Delgado Dias, Thomas and Yan, Xian and Läufer, Konstantin and Thiruvathukal, George K.},
     month = may,
     note = {Presented at the 2nd {Greater} {Chicago} {Area} {System} {Research} {Workshop} ({GCASR})},
     pdf = {https://ecommons.luc.edu/cs_facpubs/66/},
     shorttitle = {{GCASR} 13},
     title = {Building {Capable}, {Energy}-{Efficient}, {Flexible} {Visualization} and {Sensing} {Clusters} from {Commodity} {Tablets} ({Poster})},
     url = {https://ecommons.luc.edu/cs_facpubs/66/},
     year = {2013}
   }

3. SIGCSE

   Using Scala strategically across the undergraduate curriculum (Workshop)

   Mark Lewis, Konstantin Läufer, and George K. Thiruvathukal

   Mar 2013

   Presented at the 44th ACM Technical Symposium on Computer Science Education (SIGCSE ’13)

   Abs Bib Website

   Various hybrid-paradigm languages, designed to balance compile-time error detection, conciseness, and performance, have emerged. Scala, e.g., is interoperable with Java and has become an early leader in adoption, especially in the start-up and open-source spaces. Workshop participants experience Scala’s value as a teaching language in the CS curriculum through four lecture-lab modules: In CS1, the read-eval-print loop and simple, uniform syntax aid programming in the small. In CS2, higher-order methods allow concise, efficient manipulation of collections. Advanced topics include domain-specific languages, concurrency, web apps/services, and mobile apps. Laptop recommended with Scala installed.

   @misc{Lewis_SIGCSE_2013,
     abbr = {SIGCSE},
     address = {Denver, CO, USA},
     author = {Lewis, Mark and Läufer, Konstantin and Thiruvathukal, George K.},
     month = mar,
     note = {Presented at the 44th {ACM} {Technical} {Symposium} on {Computer} {Science} {Education} ({SIGCSE} '13)},
     title = {Using {Scala} strategically across the undergraduate curriculum ({Workshop})},
     url = {http://scalaworkshop.cs.luc.edu/html},
     website = {http://scalaworkshop.cs.luc.edu},
     year = {2013}
   }

4. GCASR

   Network Technologies Used to Aggregate Environmental Data (Poster)

   Paul Stasiuk, Konstantin Läufer, and George K. Thiruvathukal

   May 2013

   Presented at the 2nd Greater Chicago Area System Research Workshop (GCASR)

   Bib PDF

   @misc{Stasiuk_GCASR_2013,
     abbr = {GCASR},
     address = {Chicago, IL, USA},
     author = {Stasiuk, Paul and Läufer, Konstantin and Thiruvathukal, George K.},
     month = may,
     note = {Presented at the 2nd {Greater} {Chicago} {Area} {System} {Research} {Workshop} ({GCASR})},
     pdf = {https://ecommons.luc.edu/cs_facpubs/65/},
     shorttitle = {{GCASR} 13},
     title = {Network {Technologies} {Used} to {Aggregate} {Environmental} {Data} ({Poster})},
     url = {https://ecommons.luc.edu/cs_facpubs/65/},
     year = {2013}
   }

2012

1. EIT

   Simplifying Domain Modeling and Memory Management in User-Mode Filesystems with the NOFS Framework

   Joseph P. Kaylor, Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the IEEE International Conference on Electro/Information Technology (EIT 2012), May 2012

   Abs DOI Bib PDF

   Transparent access to remote data sets and data arising from web services is a non-trivial challenge to application developers. This early stage work addresses this challenge with NOFS, an object-oriented framework for creating filesystems to support domain specific functionality. While an early stage work, we present a solution to solve the access problem. Our solution greatly simplifies the task of filesystems development by providing the glue code needed between a domain model and the filesystem contract. We demonstrate support for domain models that are larger than physical memory and demonstrate how the concerns of caching can be removed from user-mode filesystem implementations. Future work will addresses more robust solutions to caching and other performance strategies.

   @inproceedings{Kaylor_EIT_2012,
     abbr = {EIT},
     address = {Indianapolis, IN, USA},
     author = {Kaylor, Joseph P. and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {IEEE} {International} {Conference} on {Electro}/{Information} {Technology} ({EIT} 2012)},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/EIT.2012.6220733},
     month = may,
     pdf = {https://ecommons.luc.edu/cs_facpubs/62/},
     publisher = {IEEE},
     title = {Simplifying {Domain} {Modeling} and {Memory} {Management} in {User}-{Mode} {Filesystems} with the {NOFS} {Framework}},
     url = {https://ecommons.luc.edu/cs_facpubs/62/},
     year = {2012}
   }

2. TCPP

   Early Adopter Report: PDC Modules for Every Level: A Comprehensive Model for Incorporating PDC Topics into the Existing Undergraduate Curriculum (Poster)

   Konstantin Läufer, Chandra Sekharan, George K. Thiruvathukal, and 1 more author

   May 2012

   Presented at the 2nd NSF/IEEE-CS TCPP Workshop on Parallel and Distributed Computing Education (EduPar 2012)

   Abs Bib Website

   In this short paper, we present a novel way to teach practical concurrent and parallel programming techniques within a programming languages course aimed at juniors, seniors, graduate, and professionally focused students. The overarching objective and inspiration for our effort is to enable a broad audience to develop software mainly for modern, commodity parallel/multicore hardware with shared memory, through suitable programming paradigms. Our three-credit, one-semester, 15-week course consists of five three-week modules: functional programming and immutability, programming language implementation and tools, concurrent and parallel programming (double module), and other paradigms (such as logic programming and scripting). The six-week double module on concurrent and parallel programming covers established approaches, such as threads and libraries for data- and task-parallelism, as well as emerging ones, such as actors, software-transactional memory, and functional data structures, with an emphasis on maintaining correctness while increasing performance. While aimed at a general audience, the course includes topics of interest to the scientific programmer, such as language support for units of measurement and libraries for linear algebra. Examples and assignments in a pure functional language (Haskell) and a hybrid one (F}#) are designed to enhance the students’ experience. We share our experience with the initial fall 2010 version of this course and specific plans for the upcoming spring 2012 iteration.

   @misc{Laufer_EduPar_2012,
     abbr = {TCPP},
     address = {Shanghai, China},
     author = {Läufer, Konstantin and Sekharan, Chandra and Thiruvathukal, George K. and Kaylor, Joseph P.},
     month = may,
     note = {Presented at the 2nd {NSF}/{IEEE}-{CS} {TCPP} {Workshop} on {Parallel} and {Distributed} {Computing} {Education} ({EduPar} 2012)},
     title = {Early {Adopter} {Report}: {PDC} {Modules} for {Every} {Level}: {A} {Comprehensive} {Model} for {Incorporating} {PDC} {Topics} into the {Existing} {Undergraduate} {Curriculum} ({Poster})},
     url = {https://tcpp.cs.gsu.edu/curriculum/?q=advanced-technical-program},
     website = {https://tcpp.cs.gsu.edu/curriculum/?q=advanced-technical-program},
     year = {2012}
   }

2011

1. CRC

   RestFS: The Filesystem as a Connector Abstraction for Flexible Resource and Service Composition

   Joseph P. Kaylor, Konstantin Läufer, and George K. Thiruvathukal

   In Cloud Computing: Methodology, System, and Applications, Dec 2011

   Abs DOI Bib PDF

   The broader context for this chapter comprises business scenarios requiring resource and/or service composition, such as (intra-company) enterprise application integration (EAI) and (inter-company) web service orchestration. The resources and services involved vary widely in terms of the protocols they support, which typically fall into remote procedure call (RPC)~}citeBirrell84implementingremote, resource-oriented (HTTP~}citeFielding96hypertexttransfer and WEBDAV~}citewebdav) and message-oriented protocols. By recognizing the similarity between web-based resources and the kind of resources exposed in the form of filesystems in operating systems, we have found it feasible to map the former to the latter using a uniform, configurable connector layer. Once a remote resource has been exposed in the form of a local filesystem, one can access the resource programmatically using the operating system}textquoterights standard filesystem application programming interface (API). Taking this idea one step further, one can then aggregate or otherwise orchestrate two or more remote resources using the same standard API. Filesystem APIs are available in all major operating systems. Some of those, most notably, all flavors of UNIX including GNU/Linux, have a rich collection of small, flexible command-line utilities, as well as various inter-process communication (IPC) mechanisms. These tools can be used in scripts and programs that compose the various underlying resources in powerful ways. Further explorations of the role of a filesystem-based connector layer in the enterprise application architecture have lead us to the question whether one can achieve a fully compositional, arbitrarily deep hierarchical architecture by re-exposing the aggregated resources as a single, composite resource that, in turn, can be accessed in the same form as the original resources. This is indeed possible in two flavors: 1) the composite resource can be exposed internally as a filesystem for further local composition; 2) the composite resource is exposed externally as a restful resource for further external composition. We expect the ability hierarchically to compose resources to facilitate the construction of complex, robust resource- and service-oriented software systems, and we hope that concrete case studies will further substantiate our position.

   @incollection{Kaylor_CloudBookRestFS_2011,
     abbr = {CRC},
     author = {Kaylor, Joseph P. and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Cloud {Computing}: {Methodology}, {System}, and {Applications}},
     doi = {10.1201/b11149},
     editor = {Wang, Lizhe and Ranjan, Rajiv and Chen, Jinjun and Benatallah, Boualem},
     month = dec,
     pdf = {https://ecommons.luc.edu/cs_facpubs/45/},
     publisher = {CRC Press},
     title = {{RestFS}: {The} {Filesystem} as a {Connector} {Abstraction} for {Flexible} {Resource} and {Service} {Composition}},
     url = {https://ecommons.luc.edu/cs_facpubs/45/},
     year = {2011}
   }

2. ICSOFT

   Initial experience in moving key academic department functions to social networking sites

   Konstantin Läufer, George K. Thiruvathukal, and David B. Dennis

   In Proceedings of the 6th International Conference on Software and Data Technologies (ICSOFT), Jul 2011

   Abs Bib PDF

   We discuss our initial experience with the transition from conventional technology to social networking sites and other cloud-backed sites for three core business functions of an academic computer science department at a mid-size private university: course management, research collaboration, and community engagement. We first discuss the social/cultural context that informs our technology choices, as well as the evolution of the technology choices themselves. Then, we identify the targeted department functions and their actors. Next, we describe the past and present technical architectures used to support these functions. We conclude with a discussion of our preliminary experience with this transition and to what extent our experience can be generalized into a blueprint that can be adopted by other organizations.

   @inproceedings{DBLP:conf/icsoft/2011-1,
     abbr = {ICSOFT},
     address = {Seville, Spain},
     author = {Läufer, Konstantin and Thiruvathukal, George K. and Dennis, David B.},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 6th {International} {Conference} on {Software} and {Data} {Technologies} ({ICSOFT})},
     isbn = {978-989-8425-76-8},
     month = jul,
     pdf = {https://ecommons.luc.edu/cs_facpubs/36/},
     publisher = {SciTePress},
     timestamp = {Wed, 28 Sep 2011 18:26:31 +0200},
     title = {Initial experience in moving key academic department functions to social networking sites},
     url = {https://ecommons.luc.edu/cs_facpubs/36/},
     volume = {1},
     year = {2011}
   }

3. ICSOFT

   REST on Routers? Preliminary Lessons for Language Designers, Framework Architects, and App Developers

   Joseph P. Kaylor, Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the 6th International Conference on Software and Data Technologies (ICSOFT), Jul 2011

   Abs Bib PDF

   In this position paper, we provide a preliminary assessment of hardware and software solution stack choices available to developers of resource-oriented web services on commodity embedded devices. As part of an ongoing interdisciplinary research project on air and water quality in a major urban ecosystem, we are developing an information infrastructure amounting to a role-based hierarchy of individually addressable, interconnected resources, ranging from sensors, analyzers, and other monitoring devices to aggregators and publishers. This infrastructure follows the Representational State Transfer (REST) architectural pattern and integrates non-networked or non-RESTful monitoring devices through RESTful proxy resources running on low-cost, low-energy, possibly wireless, always-on embedded servers. Commodity wireless routers running a suitable embedded Linux distribution are a good choice for this purpose, and we have started to survey the landscape of supported solution stacks, including programming languages and RESTful frameworks: Not only were our preferred, familiar choices unavailable for medium-end routers, but we had to develop our own lightweight REST layer for lower-end routers. Given the growing popularity of embedded Linux devices, however, we argue that language designers and framework architects should support them to a much greater extent than they do now. In addition, as the demand for green computing grows, we argue that memory- and processor-efficient languages and frameworks become increasingly important.

   @inproceedings{DBLP:conf/icsoft/2011-2,
     abbr = {ICSOFT},
     address = {Seville, Spain},
     author = {Kaylor, Joseph P. and Läufer, Konstantin and Thiruvathukal, George K.},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 6th {International} {Conference} on {Software} and {Data} {Technologies} ({ICSOFT})},
     isbn = {978-989-8425-76-8},
     month = jul,
     pdf = {https://ecommons.luc.edu/cs_facpubs/35/},
     publisher = {SciTePress},
     series = {{ICSOFT}},
     timestamp = {Wed, 28 Sep 2011 18:26:31 +0200},
     title = {{REST} on {Routers}? {Preliminary} {Lessons} for {Language} {Designers}, {Framework} {Architects}, and {App} {Developers}},
     url = {https://ecommons.luc.edu/cs_facpubs/35/},
     volume = {1},
     year = {2011}
   }

4. WWW

   RestFS: Resources are Filesystems, too

   Joseph P. Kaylor, Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the Second International Workshop / RESTful Design (WS-REST ’11), Mar 2011

   Abs DOI Bib PDF

   We have designed and implemented RestFS, a software framework that provides a uniform, configurable connector layer for mapping remote web-based resources to local filesystem-based resources, recognizing the similarity between these two types of resources. Such mappings enable programmatic access to a resource, as well as composition of two or more resources, through the local operating system’s standard filesystem application programming interface (API), scriptable file-based command-line utilities, and inter-process communication (IPC) mechanisms. The framework supports automatic and manual authentication. We include several examples intended to show the utility and practicality of our framework.

   @inproceedings{Kaylor_WSREST_2011,
     abbr = {WWW},
     address = {Hyderabad, India},
     author = {Kaylor, Joseph P. and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {Second} {International} {Workshop} / {RESTful} {Design} ({WS}-{REST} '11)},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1145/1967428.1967439},
     month = mar,
     pdf = {https://ecommons.luc.edu/cs_facpubs/15/},
     publisher = {Association for Computing Machinery},
     title = {{RestFS}: {Resources} are {Filesystems}, too},
     url = {https://ecommons.luc.edu/cs_facpubs/15/},
     year = {2011}
   }

5. TCPP

   PDC Modules for Every Level: A Comprehensive Model for Incorporating PDC Topics into the Existing Undergraduate Curriculum

   Konstantin Läufer, Chandra Sekharan, and George K. Thiruvathukal

   In Proceedings of the 1st NSF/IEEE-CS TCPP Workshop on Parallel and Distributed Computing Education (EduPar), May 2011

   Abs Bib Website

   We propose to give a half-hour presentation on incorporating PDC topics into our existing undergraduate computer science curriculum. We first describe our experience with single-course and cross-curricular undergraduate PDC education since 1997. We then provide details about our proposed model for incorporating PDC topics into our undergraduate curriculum. To this end, we have distilled a set of consistent, regularly offered and required three-week core and advanced PDC modules from our previously offered PDC content.

   @inproceedings{Laufer_EduPar_2011,
     abbr = {TCPP},
     address = {Anchorage, Alaska, USA},
     author = {Läufer, Konstantin and Sekharan, Chandra and Thiruvathukal, George K.},
     booktitle = {Proceedings of the 1st {NSF}/{IEEE}-{CS} {TCPP} {Workshop} on {Parallel} and {Distributed} {Computing} {Education} ({EduPar})},
     month = may,
     publisher = {IEEE},
     title = {{PDC} {Modules} for {Every} {Level}: {A} {Comprehensive} {Model} for {Incorporating} {PDC} {Topics} into the {Existing} {Undergraduate} {Curriculum}},
     url = {https://tcpp.cs.gsu.edu/curriculum/?q=node/16950},
     website = {https://tcpp.cs.gsu.edu/curriculum/?q=node/16950},
     year = {2011}
   }

6. CiSE

   Moving Academic Department Functions to Social Networks and Clouds: Initial Experiences

   Konstantin Läufer, George K. Thiruvathukal, and David B. Dennis

   Computing in Science and Engineering, May 2011

   Abs DOI Bib PDF

   The ability to move locally hosted services to cloud-based technologies is a key element in the scientific programming toolbox.

   @article{Laufer_CISE_Cloud_2011,
     abbr = {CiSE},
     author = {Läufer, Konstantin and Thiruvathukal, George K. and Dennis, David B.},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2011.85},
     journal = {Computing in Science and Engineering},
     number = {5},
     pages = {84--89},
     pdf = {https://ecommons.luc.edu/cs_facpubs/144/},
     shorttitle = {Moving {Academic} {Department} {Functions} to {Social} {Networks} and {Clouds}},
     title = {Moving {Academic} {Department} {Functions} to {Social} {Networks} and {Clouds}: {Initial} {Experiences}},
     url = {https://ecommons.luc.edu/cs_facpubs/144/},
     volume = {13},
     year = {2011}
   }

2010

1. EIT

   Online Layered File System (OLFS): A layered and versioned filesystem and performance analysis

   Joseph P. Kaylor, Konstantin Läufer, and George K. Thiruvathukal

   In Proceedings of the IEEE International Conference on Electro/Information Technology (EIT 2010), May 2010

   Abs DOI Bib PDF

   We present a novel form of intra-volume directory layering with hierarchical, inheritance-like namespace unification. While each layer of an OLFS volume constitutes a subvolume that can be mounted separately in a fan-in configuration, the entire hierarchy is always accessible (online) and fully navigable through any mounted layer. OLFS uses a relational database to store its layering metadata and either a relational database or any (virtual) host file system as its backing store, along with metadata and block caching for improved performance. Because OLFS runs as a virtual file system in user-space, its capabilities are available to all existing software without modification or special privileges. We have developed a reference implementation of OLFS for FUSE based on MySQL and XFS, and conducted performance benchmarking against XFS by itself. We explore several applications of OLFS, such as enhanced server synchronization, transactional file operations, and versioning.

   @inproceedings{Kaylor_EIT_2010,
     abbr = {EIT},
     address = {Normal, IL, USA},
     author = {Kaylor, Joseph P. and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {IEEE} {International} {Conference} on {Electro}/{Information} {Technology} ({EIT} 2010)},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/EIT.2010.5612094},
     month = may,
     pages = {1--9},
     pdf = {https://ecommons.luc.edu/cs_facpubs/40},
     publisher = {IEEE},
     shorttitle = {Online {Layered} {File} {System} ({OLFS})},
     title = {Online {Layered} {File} {System} ({OLFS}): {A} layered and versioned filesystem and performance analysis},
     url = {https://ecommons.luc.edu/cs_facpubs/40},
     year = {2010}
   }

2. CiSE

   Virtualization for Computational Scientists

   George K. Thiruvathukal, Konstantin Läufer, Konrad Hinsen, and 1 more author

   Computing in Science and Engineering, May 2010

   Abs DOI Bib PDF

   Virtualization lets you carve your computer into slices, allowing for great experimentation with different operating systems, tools, and techniques.

   @article{Thiruvathukal_CISE_Virtualization_2010,
     abbr = {CiSE},
     author = {Thiruvathukal, George K. and Läufer, Konstantin and Hinsen, Konrad and Kaylor, Joseph P.},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2010.92},
     journal = {Computing in Science and Engineering},
     number = {4},
     pages = {52--61},
     pdf = {https://ecommons.luc.edu/cs_facpubs/16/},
     title = {Virtualization for {Computational} {Scientists}},
     url = {https://ecommons.luc.edu/cs_facpubs/16/},
     volume = {12},
     year = {2010}
   }

2009

1. ICWS

   GroupSpeak: High-level Language Extension for Workflow Capability

   Moshe Gutman, Sridhar Radhakrishnan, Changwook Kim, and 2 more authors

   In Proceedings of the IEEE International Conference on Web Services (ICWS 2009), Jul 2009

   Abs DOI Bib

   Currently, workflow systems are either XML based or component based. Both paradigms have usability deficiencies. XML is not designed for procedural programming. Legacy code is difficult to adapt to component based systems. We propose a new paradigm by adding workflow keywords to an existing high-level language. This approach, called GroupSpeak, uses a procedural style of programming and allows for easy introduction of workflow patterns to legacy code. The programmer can leverage their existing knowledge of the high-level language to easily add workflow capabilities to their applications.

   @inproceedings{DBLP:conf/icws/GutmanRKSL09,
     abbr = {ICWS},
     address = {Los Angeles, CA, USA},
     author = {Gutman, Moshe and Radhakrishnan, Sridhar and Kim, Changwook and Sekharan, Chandra N. and Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the {IEEE} {International} {Conference} on {Web} {Services} ({ICWS} 2009)},
     doi = {10.1109/ICWS.2009.135},
     month = jul,
     pages = {1035--1036},
     publisher = {IEEE Computer Society},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {{GroupSpeak}: {High}-level {Language} {Extension} for {Workflow} {Capability}},
     year = {2009}
   }

2. CiSE

   Essential Tools: Version Control Systems

   Konrad Hinsen, Konstantin Läufer, and George K. Thiruvathukal

   Computing in Science and Engineering, Jul 2009

   Abs DOI Bib PDF

   Did you ever wish you’d made a backup copy of a file before changing it? Or before applying a collaborator’s modifications? Version control systems make this easier, and do a lot more.

   @article{Hinsen_CISE_VCS_2009,
     abbr = {CiSE},
     author = {Hinsen, Konrad and Läufer, Konstantin and Thiruvathukal, George K.},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2009.194},
     journal = {Computing in Science and Engineering},
     number = {6},
     pages = {84--91},
     pdf = {https://ecommons.luc.edu/cs_facpubs/27/},
     shorttitle = {Essential {Tools}},
     title = {Essential {Tools}: {Version} {Control} {Systems}},
     url = {https://ecommons.luc.edu/cs_facpubs/27/},
     volume = {11},
     year = {2009}
   }

3. CiSE

   Scientific Programming: The Promises of Typed, Pure, and Lazy Functional Programming: Part II

   Konstantin Läufer, and George K. Thiruvathukal

   Computing in Science and Engineering, Jul 2009

   Abs DOI Bib PDF

   This second installment picks up where Konrad Hinsen’s article "The Promises of Functional Programming" from the July/August 2009 issue left off, covering static type inference and lazy evaluation in functional programming languages. In the first installment in this series on functional programming, Konrad Hinsen introduced the functional programming paradigm, which encourages recursion and higher-order functional abstraction in algorithms. In this second installment, we explore several other aspects of the functional paradigm. Using examples in the Closure, Java, and Haskell languages, we discuss some of the benefits of static typing with type inference and pure, side-effect-free functional programming with lazy evaluation. In particular, we argue that these features make Haskell a compelling choice for general software development. The scientific computing community, however, likely require better numeric library support and efficient functional versions of scientific algorithms before accepting Haskell more widely.

   @article{Laufer_CISE_Functional2_2009,
     abbr = {CiSE},
     author = {Läufer, Konstantin and Thiruvathukal, George K.},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2009.147},
     journal = {Computing in Science and Engineering},
     number = {5},
     pages = {68--75},
     pdf = {https://ecommons.luc.edu/cs_facpubs/25/},
     shorttitle = {Scientific {Programming}},
     title = {Scientific {Programming}: {The} {Promises} of {Typed}, {Pure}, and {Lazy} {Functional} {Programming}: {Part} {II}},
     url = {https://ecommons.luc.edu/cs_facpubs/25/},
     volume = {11},
     year = {2009}
   }

4. CiSE

   Putting a Slug to Work

   Konstantin Läufer, George K. Thiruvathukal, Ryohei Nishimura, and 1 more author

   Computing in Science and Engineering, Jul 2009

   Abs DOI Bib PDF

   In this article, the authors explore various uses of inexpensive embedded Linux devices such as the Linksys NSLU2 ("slug"). Embedded computing is a topic of growing interest. Although novel architectures such as cell processors, graphics processors (GPUs), and FPGAs are growing in popularity, conventional microproessor designs such as Intel’s Xscale (ARM) and Atom pack a punch in a small footprint, not to mention being widely supported by commodity operating system and development tools. We’re convinced that this entire space is a tool worth keeping in the scientific programmer’s and software developer’s toolchests.

   @article{Laufer_CISE_Slug_2007,
     abbr = {CiSE},
     author = {Läufer, Konstantin and Thiruvathukal, George K. and Nishimura, Ryohei and Martínez-Eiroa, Carlos Ramírez},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2009.35},
     journal = {Computing in Science and Engineering},
     number = {2},
     pages = {62--68},
     pdf = {https://ecommons.luc.edu/cs_facpubs/23/},
     title = {Putting a {Slug} to {Work}},
     url = {https://ecommons.luc.edu/cs_facpubs/23/},
     volume = {11},
     year = {2009}
   }

2008

1. EIT

   Taming XML: Objects First, Then Markup

   Matt Bone, Peter F. Nabicht, Konstantin Läufer, and 1 more author

   In Proceedings of the IEEE International Conference on Electro/Information Technology (EIT 2008), May 2008

   Abs DOI Bib PDF

   Processing markup in object-oriented languages often requires the programmer to focus on the objects generating the markup rather than the more pertinent domain objects. The BetterXML framework aims to improve this situation by allowing the programmer to develop a domain-specific object model as usual and later bind this model to preexisting or newly generated markup. To this end, the framework provides two types of object trees, XElement and NaturalXML, for representing XML documents. XElement goes beyond DOM-like automatic parsing of XML by supporting the custom mapping of elements to domain objects; NaturalXML allows the mapping of existing domain objects to XML elements using class metadata. Both types of object trees can be inflated and deflated by means of a common intermediate representation in the form of an event stream. Finally, the framework includes the XML Intermediate Representation (XIR), a lossless record-oriented representation of XML documents for efficient streaming and other types of data exchange.

   @inproceedings{Bone_EIT_2008,
     abbr = {EIT},
     address = {Ames, IA, USA},
     author = {Bone, Matt and Nabicht, Peter F. and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {Proceedings of the {IEEE} {International} {Conference} on {Electro}/{Information} {Technology} ({EIT} 2008)},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/EIT.2008.4554352},
     month = may,
     pages = {488--493},
     pdf = {https://ecommons.luc.edu/cs_facpubs/39},
     publisher = {IEEE},
     shorttitle = {Taming {XML}},
     title = {Taming {XML}: {Objects} {First}, {Then} {Markup}},
     url = {https://ecommons.luc.edu/cs_facpubs/39},
     year = {2008}
   }

2. SEKE

   Combining SOA and BPM Technologies for Cross-System Process Automation

   Sebastian Herr, Konstantin Läufer, John Shafaee, and 2 more authors

   In Proceedings of the Twentieth International Conference on Software Engineering & Knowledge Engineering (SEKE 2008), Jul 2008

   Abs Bib PDF Website

   This paper summarizes the results of an industry case study that introduced a cross-system business process automation solution based on a combination of SOA and BPM standard technologies (i.e., BPMN, BPEL, WSDL). Besides discussing major weaknesses of the existing, custom-built, solution and comparing them against experiences with the developed prototype, the paper presents a course of action for transforming the current solution into the proposed solution. This includes a general approach, consisting of four distinct steps, as well as specific action items that are to be performed for every step. The discussion also covers language and tool support and challenges arising from the transformation.

   @inproceedings{DBLP:conf/seke/HerrLSTW08,
     abbr = {SEKE},
     address = {San Francisco, CA, USA},
     author = {Herr, Sebastian and Läufer, Konstantin and Shafaee, John and Thiruvathukal, George K. and Wirtz, Guido},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the {Twentieth} {International} {Conference} on {Software} {Engineering} \& {Knowledge} {Engineering} ({SEKE} 2008)},
     isbn = {978-1-62748-662-0},
     month = jul,
     pages = {339--344},
     pdf = {https://works.bepress.com/laufer/10/},
     publisher = {Knowledge Systems Institute},
     title = {Combining {SOA} and {BPM} {Technologies} for {Cross}-{System} {Process} {Automation}},
     url = {https://www.proceedings.com/18678.html},
     website = {https://www.proceedings.com/18678.html},
     year = {2008}
   }

3. CiSE

   A Stroll through Domain-Driven Development with Naked Objects

   Konstantin Läufer

   Computing in Science & Engineering, Jul 2008

   Abs DOI Bib

   With the help of domain-driven development frameworks such as Naked Objects for Java, changes to an application’s core functionality propagate automatically to the user interface and persistence layers.

   @article{DBLP:journals/cse/Laufer08,
     abbr = {CiSE},
     author = {Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1109/MCSE.2008.67},
     journal = {Computing in Science \& Engineering},
     number = {3},
     pages = {76--83},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {A {Stroll} through {Domain}-{Driven} {Development} with {Naked} {Objects}},
     volume = {10},
     year = {2008}
   }

4. CiSE

   What I Did on My Summer Vacation

   George K. Thiruvathukal, and Konstantin Läufer

   Computing in Science and Engineering, Jul 2008

   Abs DOI Bib

   The department editors discuss the continuing importance of requirements, managing Web content, free public Wi-Fi, and a recent personal transition to Internet telephony.

   @article{Thiruvathukal_CISE_Summer_2008,
     abbr = {CiSE},
     author = {Thiruvathukal, George K. and Läufer, Konstantin},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2008.159},
     journal = {Computing in Science and Engineering},
     number = {6},
     pages = {76--81},
     title = {What {I} {Did} on {My} {Summer} {Vacation}},
     volume = {10},
     year = {2008}
   }

2007

1. IPDPS

   A Model-Driven Approach to Job/Task Composition in Cluster Computing

   Neeraj Mehta, Yogesh Kanitkar, Konstantin Läufer, and 1 more author

   In 2007 IEEE International Parallel and Distributed Processing Symposium (IPDPS), Mar 2007

   Abs DOI Bib

   In the general area of high-performance computing, object-oriented methods have gone largely unnoticed. In contrast, the computational neighborhood (CN), a framework for parallel and distributed computing with a focus on cluster computing, was designed from ground up to be object-oriented. This paper describes how we have successfully used UML in the following model-driven, generative approach to job/task composition in CN. We model CN jobs using activity diagrams in any modeling tool with support for XMI, an XML-based external representation of UML models. We then export the activity diagrams and use our XSLT-based tool to transform the resulting XMI representation to CN job/task composition descriptors.

   @inproceedings{Mehta_IPDPS_2007,
     abbr = {IPDPS},
     address = {Long Beach, CA, USA},
     author = {Mehta, Neeraj and Kanitkar, Yogesh and Läufer, Konstantin and Thiruvathukal, George K.},
     booktitle = {2007 {IEEE} {International} {Parallel} and {Distributed} {Processing} {Symposium} ({IPDPS})},
     doi = {10.1109/IPDPS.2007.370423},
     month = mar,
     pages = {1--8},
     publisher = {IEEE},
     title = {A {Model}-{Driven} {Approach} to {Job}/{Task} {Composition} in {Cluster} {Computing}},
     year = {2007}
   }

2. CiSE

   A Hike through a Post-EJB J2EE Web Application Architecture, Part III

   Konstantin Läufer, George K. Thiruvathukal, and Benjamin González

   Computing in Science and Engineering, Mar 2007

   Abs DOI Bib PDF

   By incorporating automated component, integration, and acceptance testing into the various tiers of a lightweight lava 2 Enterprise Edition (J2EE) Web application architecture, developers can shorten the development cycle and increase the quality of their work

   @article{Laufer_CISE_Hike3_2007,
     abbr = {CiSE},
     author = {Läufer, Konstantin and Thiruvathukal, George K. and González, Benjamin},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2007.2},
     journal = {Computing in Science and Engineering},
     number = {1},
     pdf = {https://ecommons.luc.edu/cs_facpubs/263/},
     title = {A {Hike} through a {Post}-{EJB} {J2EE} {Web} {Application} {Architecture}, {Part} {III}},
     url = {https://ecommons.luc.edu/cs_facpubs/263/},
     volume = {9},
     year = {2007}
   }

2006

1. CiSE

   A Hike through Post-EJB J2EE Web Application Architecture, Part II

   Konstantin Läufer

   Computing in Science & Engineering, Mar 2006

   Abs DOI Bib

   This is the second article in an occasional series on Web application development. The first installment, published in the September/October 2005 issue ("A Hike through Post-EJB J2EE Web Application Architecture," vol. 7, no. 5, pp. 80-88), focused on the upper tiers that comprise the user interface; here, the author focuses on the lower tiers. He started with a blueprint of a typical post-Enterprise JavaBeans (EJB) Java 2 Enterprise Edition (J2EE) Web application architecture. Several functional and nonfunctional requirements drive such architectures, and they’ve become relatively standard. Within this architecture, we looked at the core functionality of our running example - linear regression over a persistent set of points - and then hiked our way upward through successive user interface layers, including dynamic behavior, presentation, internationalization, navigation, layout, and visual styles. During the hike, we looked at typical technologies for each layer. In this article, we descend into our application’s invisible innards. Specifically, the author examines business service objects, object-relational mappings, lightweight containers (for painlessly connecting the various pieces), security, and concurrency. Our ultimate goal is to facilitate the development of reliable, flexible, and efficient server-based Web applications.

   @article{DBLP:journals/cse/Laufer06,
     abbr = {CiSE},
     author = {Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1109/MCSE.2006.20},
     journal = {Computing in Science \& Engineering},
     number = {2},
     pages = {79--87},
     timestamp = {Thu, 12 Mar 2020 00:00:00 +0100},
     title = {A {Hike} through {Post}-{EJB} {J2EE} {Web} {Application} {Architecture}, {Part} {II}},
     volume = {8},
     year = {2006}
   }

2. CiSE

   Unit Testing Considered Useful

   George K. Thiruvathukal, Konstantin Läufer, and Benjamin González

   Computing in Science and Engineering, Mar 2006

   Abs DOI Bib PDF

   Testing is an important part of application development hardware engineers, in particular, have a long established history of testing for the obvious reason that it’s awfully hard to rebuild a microprocessor every time a bug pops up in the design stage-not to mention the enormous headaches such bugs generate on the software side. In this installment of Scientific Programming, we’ll discuss the role of testing in the software development process and examine ways to leverage automated unit testing in your projects

   @article{Thiruvathukal_CISE_Testing_2006,
     abbr = {CiSE},
     author = {Thiruvathukal, George K. and Läufer, Konstantin and González, Benjamin},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2006.124},
     journal = {Computing in Science and Engineering},
     number = {6},
     pages = {76--87},
     pdf = {https://ecommons.luc.edu/cs_facpubs/33/},
     title = {Unit {Testing} {Considered} {Useful}},
     url = {https://ecommons.luc.edu/cs_facpubs/33/},
     volume = {8},
     year = {2006}
   }

2005

1. CiSE

   A hike through post-EJB J2EE Web application architecture

   Konstantin Läufer

   Computing in Science & Engineering, Mar 2005

   Abs DOI Bib

   Since the mid-nineties, server-based Web applications have emerged as a convenient way to provide functionality to a user audience without any specific software or system requirements except the need for a reasonably up-to-date Web browser. The tricky integration, installation, and configuration tasks are under the control of an expert on the server side. These advantages apply to both the general public and small research teams. Typical Web applications have browser-based user interfaces for one or more user roles and might keep some information in persistent storage, such as a relational database. Since the early days of common gateway interface (CGI) scripting, technologies for developing Web applications have evolved by leaps and bounds to address growing expectations with respect to reliability, maintainability, extensibility, performance, scalability, and other goals. In this article - the first in a planned series about Web application development - we take an exploratory hike through the architectural layers of a Web application built with state-of-the-art, widely used technologies. The paper focus on the upper layers that provide the application’s user interface. By no means intended as a complete treatise on Web application development, this article is an overview meant to spark your interest and provide a starting Doint for further exploration.

   @article{DBLP:journals/cse/Laufer05,
     abbr = {CiSE},
     author = {Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1109/MCSE.2005.85},
     journal = {Computing in Science \& Engineering},
     number = {5},
     pages = {80--88},
     timestamp = {Thu, 12 Mar 2020 00:00:00 +0100},
     title = {A hike through post-{EJB} {J2EE} {Web} application architecture},
     volume = {7},
     year = {2005}
   }

2004

1. CiSE

   Plone and Content Management

   George K. Thiruvathukal, and Konstantin Läufer

   Computing in Science and Engineering, Mar 2004

   Abs DOI Bib PDF

   This paper looks at Plone, one of the best content management systems. Plone is distributed under a free open-source license: the cost of getting started is only limited to the time you have available to set up the software on a server. Plone is written in Python and uses the Zope application server infrastructure; it runs on most modern operating systems. Plone can be customized for the maintenance of content - entirely over the Web.

   @article{Thiruvathukal_CISE_Plone_2004,
     abbr = {CiSE},
     author = {Thiruvathukal, George K. and Läufer, Konstantin},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCSE.2004.19},
     journal = {Computing in Science and Engineering},
     number = {4},
     pages = {88--95},
     pdf = {https://ecommons.luc.edu/cs_facpubs/30/},
     title = {Plone and {Content} {Management}},
     url = {https://ecommons.luc.edu/cs_facpubs/30/},
     volume = {6},
     year = {2004}
   }

2. CiSE

   Natural XML for Data Binding, Processing, and Persistence

   George K. Thiruvathukal, and Konstantin Läufer

   Computing in Science and Engineering, Mar 2004

   Abs DOI Bib PDF

   The article explains what you need to do to incorporate XML directly into your computational science application. The exploration involves the use of a standard parser to automatically build object trees entirely from application-specific classes. This discussion very much focuses on object-oriented programming languages such as Java and Python, but it can work for non-object-oriented languages as well. The ideas in the article provide a glimpse into the Natural XML research project.

   @article{Thiruvathukal_CISE_XML_2004,
     abbr = {CiSE},
     author = {Thiruvathukal, George K. and Läufer, Konstantin},
     copyright = {Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC-BY-NC-SA)},
     doi = {10.1109/MCISE.2004.1267615},
     journal = {Computing in Science and Engineering},
     number = {2},
     pages = {86--92},
     pdf = {https://ecommons.luc.edu/cs_facpubs/9/},
     title = {Natural {XML} for {Data} {Binding}, {Processing}, and {Persistence}},
     url = {https://ecommons.luc.edu/cs_facpubs/9/},
     volume = {6},
     year = {2004}
   }

2003

1. IC

   Mockup Supporting Web Requirements Engineering

   Jia Zhang, Konstantin Läufer, and Zhiguo Gong

   In Proceedings of the International Conference on Internet Computing, (IC ’03), Jun 2003

   Abs Bib PDF

   Requirements engineering for web applications entails new demands, compared to traditional software applications. This paper proposes a mockup-driven fast prototyping methodology to help elicit and finalize system requirements, as well as facilitate adjustments to quickly changing user requirements typical of web applications. This strategy minimizes the risk of wasting valuable development efforts because of ambiguous or incomplete requirement specifications.

   @inproceedings{DBLP:conf/ic/ZhangLG03,
     abbr = {IC},
     address = {Las Vegas, Nevada, USA},
     author = {Zhang, Jia and Läufer, Konstantin and Gong, Zhiguo},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the {International} {Conference} on {Internet} {Computing}, ({IC} '03)},
     editor = {Arabnia, Hamid R. and Mun, Youngsong},
     month = jun,
     pages = {684--687},
     pdf = {https://s2.smu.edu/{\textasciitilde}jiazhang/Papers/JiaZhang-MockupWRE.pdf},
     publisher = {CSREA Press},
     title = {Mockup {Supporting} {Web} {Requirements} {Engineering}},
     year = {2003}
   }

2. Using handheld and wireless technology for classroom and community-based South Asian language pedagogy

   Christopher Chung, Daisy Rockwell, Tao Bai, and 2 more authors

   Jun 2003

   Presented at the 2003 Midwest Software Engineering Conference, Chicago, Illinois

   Abs Bib PDF

   This interdisciplinary project explores the potential for handheld/wireless (H/W) technology in the context of language education within and beyond the classroom. Specifically, we have designed and implemented a suite of multi-platform (desktop/laptop, handheld, and browser) applications to enhance the teaching of South Asian languages such as Hindi-Urdu. Such languages are very difficult to learn, let alone write, and H/W devices (with their handwriting/drawing capabilities) can play a significant role in overcoming the learning curve. The initial application suite includes a character/word tracer, a word splitter/joiner, a smart flashcard with audio, contextual augmented stories for reading comprehension, and a poetic metronome. We have received preliminary user feedback and are planning to conduct more formal experiments to test the effectiveness of our applications. To facilitate building ubiquitous learning communities, we are planning to enhance our existing applications to leverage wireless connectivity, as well as identify additional applications that will benefit from this capability.

   @misc{chung2003,
     address = {Chicago, IL, USA},
     author = {Chung, Christopher and Rockwell, Daisy and Bai, Tao and Läufer, K and Thiruvathukal, George K},
     month = jun,
     note = {Presented at the 2003 {Midwest} {Software} {Engineering} {Conference}, {Chicago}, {Illinois}},
     pdf = {https://ecommons.luc.edu/cs_facpubs/2/},
     title = {Using handheld and wireless technology for classroom and community-based {South} {Asian} language pedagogy},
     url = {https://ecommons.luc.edu/cs_facpubs/2/},
     year = {2003}
   }

3. Patent

   Method and apparatus for providing interactive services with multiple interfaces

   Thomas J Ball, Peter John Danielsen, Lalita Jategaonkar Jagadeesan, and 3 more authors

   Mar 2003

   Bib Website

   @patent{ball2003method1,
     abbr = {Patent},
     assignee = {Lucent Technologies Inc.},
     author = {Ball, Thomas J and Danielsen, Peter John and Jagadeesan, Lalita Jategaonkar and Läufer, Konstantin and Mataga, Peter Andrew and Rehor, Kenneth G},
     month = mar,
     number = {US6529863B1},
     title = {Method and apparatus for providing interactive services with multiple interfaces},
     url = {https://patents.google.com/patent/US6529863B1},
     website = {https://patents.google.com/patent/US6529863B1},
     year = {2003}
   }

4. Patent

   Method and apparatus for providing interactive services with multiple interfaces

   Thomas J Ball, Peter John Danielsen, Lalita Jategaonkar Jagadeesan, and 3 more authors

   Aug 2003

   Bib Website

   @patent{ball2003method2,
     abbr = {Patent},
     assignee = {Lucent Technologies Inc.},
     author = {Ball, Thomas J and Danielsen, Peter John and Jagadeesan, Lalita Jategaonkar and Läufer, Konstantin and Mataga, Peter Andrew and Rehor, Kenneth G},
     month = aug,
     number = {US6609089B1},
     title = {Method and apparatus for providing interactive services with multiple interfaces},
     url = {https://patents.google.com/patent/US6609089B1},
     website = {https://patents.google.com/patent/US6609089B1},
     year = {2003}
   }

5. Enhancing the CS Curriculum with with Aspect-Oriented Software Development (AOSD) and Early Experience

   Konstantin Läufer, George K. Thiruvathukal, and Tzilla Elrad

   Sep 2003

   Technical Report

   Abs Bib PDF

   Aspect-oriented software development (AOSD) is evolving as an important step beyond existing software development approaches such as object-oriented development. An aspect is a module that captures a crosscutting concern, behavior that cuts across different units of abstraction in a software application; expressed as a module, such behavior can be enabled and disabled transparently and non-invasively, without changing the application code itself. Increasing industry demand for expertise in AOSD gives rise to the pedagogical challenge of covering this methodology and its foundations in the computer science curriculum. We present our curricular initiative to incorporate a novel course in AOSD in the undergraduate computer science curriculum at the intermediate level. We also discuss recent and planned efforts to integrate coverage of AOSD into existing courses.

   @techreport{Laufer_AOSD_2003,
     author = {Läufer, Konstantin and Thiruvathukal, George K. and Elrad, Tzilla},
     institution = {Loyola University Chicago},
     month = sep,
     note = {Technical {Report}},
     pdf = {https://ecommons.luc.edu/cs_facpubs/4/},
     title = {Enhancing the {CS} {Curriculum} with with {Aspect}-{Oriented} {Software} {Development} ({AOSD}) and {Early} {Experience}},
     url = {https://ecommons.luc.edu/cs_facpubs/4/},
     year = {2003}
   }

2002

1. Half & Half: Multiple Dispatch and Retroactive Abstraction for Java

   Gerald Baumgartner, Martin Jansche, and Konstantin Läufer

   Mar 2002

   Technical Report

   Abs Bib PDF

   Software often goes through a variety of extensions during its lifetime: adding new fields or new variants to a data structure, retroactively creating new type abstractions, and adding new operations on a data structure. As characterized by the extensibility problem, it should be possible to apply any combination of these types of extensions in any order. Mainstream object-oriented languages, however, do not well support the latter two. This paper proposes two language mechanisms that facilitate extending existing type hierarchies: multimethod dispatch and retroactive abstraction. For these two mechanisms to coexist, it is necessary to allow method dispatch on parameters of interface types, which presents problems with static type-checking. We present a type-safe solution that combines the two mechanisms by limiting multimethod type checks to package boundaries and by compiling certain packages with multimethods into sealed Jar files

   @techreport{BaumgartnerHalf2002,
     author = {Baumgartner, Gerald and Jansche, Martin and Läufer, Konstantin},
     institution = {Purdue University},
     month = mar,
     note = {Technical {Report}},
     number = {OSU-CISRC-5/01-TR08},
     pdf = {https://www.csc.lsu.edu/{\textasciitilde}gb/Brew/Publications/HalfNHalf.pdf},
     title = {Half \& {Half}: {Multiple} {Dispatch} and {Retroactive} {Abstraction} for {Java}},
     url = {https://www.csc.lsu.edu/~gb/Brew/Publications/HalfNHalf.pdf},
     year = {2002}
   }

2000

1. CP

   A Constraint-Based Framework for Prototyping Distributed Virtual Applications

   Vineet Gupta, Lalita Jategaonkar Jagadeesan, Radha Jagadeesan, and 2 more authors

   In Proceedings of the 6th International Conference on Principles and Practice of Constraint Programming (CP 2000), Sep 2000

   Abs DOI Bib

   This paper describes the architecture and implementation of a constraint-based framework for rapid prototyping of distributed applications such as virtual simulations, collaborations and games. Our framework integrates three components based on (concurrent) constraint programming ideas: (1) Hybrid cc, a (concurrent) constraint modeling language for hybrid systems, (2) Sisl, a (discrete) timed constraint language for describing interactive services with flexible user interfaces and (3) Triveni, a process-algebraic language for concurrent programming. The framework is realized as a collection of tools implemented in Java. The utility of the ideas are illustrated by sketching the implementations of simple distributed applications.

   @inproceedings{DBLP:conf/cp/GuptaJJJL00,
     abbr = {CP},
     address = {Singapore},
     author = {Gupta, Vineet and Jagadeesan, Lalita Jategaonkar and Jagadeesan, Radha and Jiang, Xiaowei and Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 6th {International} {Conference} on {Principles} and {Practice} of {Constraint} {Programming} ({CP} 2000)},
     doi = {10.1007/3-540-45349-0_16},
     editor = {Dechter, Rina},
     month = sep,
     pages = {202--217},
     publisher = {Springer},
     series = {Lecture {Notes} in {Computer} {Science}},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {A {Constraint}-{Based} {Framework} for {Prototyping} {Distributed} {Virtual} {Applications}},
     volume = {1894},
     year = {2000}
   }

2. FSE

   Automated systematic testing for constraint-based interactive services

   Patrice Godefroid, Lalita Jategaonkar Jagadeesan, Radha Jagadeesan, and 1 more author

   In Proceedings of the ACM SIGSOFT Symposium on Foundations of Software Engineering, Nov 2000

   Abs DOI Bib

   Constraint-based languages can express in a concise way the complex logic of a new generation of interactive services for applications such as banking or stock trading, that must support multiple types of interfaces for accessing the same data. These include automatic speech-recognition interfaces where inputs may be provided in any order by users of the service. We study in this paper how to systematically test event-driven applications developed using such languages. We show how such applications can be tested automatically, without the need for any manually-written test cases, and efficiently, by taking advantage of their capability of taking unordered sets of events as inputs.

   @inproceedings{DBLP:conf/sigsoft/GodefroidJJL00,
     abbr = {FSE},
     address = {San Diego, CA, USA},
     author = {Godefroid, Patrice and Jagadeesan, Lalita Jategaonkar and Jagadeesan, Radha and Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the {ACM} {SIGSOFT} {Symposium} on {Foundations} of {Software} {Engineering}},
     doi = {10.1145/355045.355051},
     editor = {Knight, John C. and Rosenblum, David S.},
     month = nov,
     pages = {40--49},
     publisher = {Association for Computing Machinery},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {Automated systematic testing for constraint-based interactive services},
     year = {2000}
   }

3. CJ

   Safe Structural Conformance for Java

   Konstantin Läufer, Gerald Baumgartner, and Vincent F. Russo

   Computer Journal, Nov 2000

   Abs DOI Bib

   In Java, an interface specifies public abstract methods and associated public constants. Conformance of a class to an interface is by name. We propose to allow structural conformance to interfaces: any class or interface that declares or implements each method in a target interface conforms structurally to the interface, and any expression of the source class or interface type can be used where a value of the target interface type is expected. We argue that structural conformance results in a major gain in flexibility in situations that require retroactive abstraction over types. Structural conformance requires no additional syntax and only small modifications to the Java compiler and optionally, for performance reasons, the virtual machine, resulting in a minor performance penalty. Our extension is type-safe: a cast-free program that compiles without errors will not have any type errors at run time. Our extension is conservative: existing Java programs still compile and run in the same manner as under the original language definition. Finally, structural conformance works well with recent extensions such as Java remote method invocation. We have implemented our extension of Java with structural interface conformance by modifying the Java Developers Kit 1.1.5 source release for Solaris and Windows 95/NT. We have also created a test suite for the extension.

   @article{DBLP:journals/cj/LauferBR00,
     abbr = {CJ},
     author = {Läufer, Konstantin and Baumgartner, Gerald and Russo, Vincent F.},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1093/comjnl/43.6.469},
     journal = {Computer Journal},
     number = {6},
     pages = {469--481},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {Safe {Structural} {Conformance} for {Java}},
     volume = {43},
     year = {2000}
   }

4. IJST

   Sisl: Several Interfaces, Single Logic

   Thomas Ball, Christopher Colby, Peter J. Danielsen, and 5 more authors

   International Journal of Speech Technology, Nov 2000

   Abs DOI Bib

   Modern interactive services such as information and e-commerce services are becoming increasingly more flexible in the types of user interfaces they support. These interfaces incorporate automatic speech recognition and natural language understanding and include graphical user interfaces on the desktop and web-based interfaces using applets and HTML forms. To what extent can the user interface software be decoupled from the service logic software (the code that defines the essential function of a service)? Decoupling of user interface from service logic directly impacts the flexibility of services, or how easy they are to modify and extend. To explore these issues, we have developed Sisl, an architecture and domain-specific language for designing and implementing interactive services with multiple user interfaces. A key principle underlying Sisl is that all user interfaces to a service share the same service logic. Sisl provides a clean separation between the service logic and the software for a variety of interfaces, including Java applets, HTML pages, speech-based natural language dialogue, and telephone-based voice access. Sisl uses an event-based model of services that allows service providers to support interchangeable user interfaces (or add new ones) to a single consistent source of service logic and data. As part of a collaboration between research and development, Sisl is being used to prototype a new generation of call processing services for a Lucent Technologies switching product.

   @article{DBLP:journals/ijst/BallCDJJLMR00,
     abbr = {IJST},
     author = {Ball, Thomas and Colby, Christopher and Danielsen, Peter J. and Jagadeesan, Lalita Jategaonkar and Jagadeesan, Radha and Läufer, Konstantin and Mataga, Peter and Rehor, Kenneth},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1023/A:1009645414233},
     journal = {International Journal of Speech Technology},
     number = {2},
     pages = {93--108},
     timestamp = {Mon, 08 Jun 2020 01:00:00 +0200},
     title = {Sisl: {Several} {Interfaces}, {Single} {Logic}},
     volume = {3},
     year = {2000}
   }

5. SIGSOFT

   The Triveni project

   Radha Jagadeesan, Konstantin Läufer, and Vineet Gupta

   ACM SIGSOFT Software Engineering Notes, Nov 2000

   DOI Bib

   @article{DBLP:journals/sigsoft/JagadeesanLG00,
     abbr = {SIGSOFT},
     author = {Jagadeesan, Radha and Läufer, Konstantin and Gupta, Vineet},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1145/340855.340962},
     journal = {ACM SIGSOFT Software Engineering Notes},
     number = {1},
     pages = {59},
     timestamp = {Thu, 17 Sep 2020 01:00:00 +0200},
     title = {The {Triveni} project},
     volume = {25},
     year = {2000}
   }

1998

1. OOPSLA

   Interaction, Concurrency, and OOP in the Curriculum: a Sophomore Course

   Christopher Colby, Radha Jagadeesan, Konstantin Läufer, and 1 more author

   In Proceedings of the OOPSLA 1998 Educators’ Symposium, Oct 1998

   Bib PDF

   @inproceedings{Colby_OOPSLAEDU_1998,
     abbr = {OOPSLA},
     address = {Vancouver, Canada},
     author = {Colby, Christopher and Jagadeesan, Radha and Läufer, Konstantin and Sekharan, Chandra},
     booktitle = {Proceedings of the {OOPSLA} 1998 {Educators}' {Symposium}},
     month = oct,
     pdf = {Colby\_Curriculum\_1998.pdf},
     publisher = {Association for Computing Machinery},
     title = {Interaction, {Concurrency}, and {OOP} in the {Curriculum}: a {Sophomore} {Course}},
     year = {1998}
   }

2. COOTS

   Objects and Concurrency in Triveni: A Telecommunication Case Study in Java

   Christopher Colby, Lalita Jategaonkar Jagadeesan, Radha Jagadeesan, and 2 more authors

   In Proceedings of the 4th USENIX Conference on Object-Oriented Technologies and Systems (COOTS), Apr 1998

   Abs Bib Website

   We describe the interaction of objects and concurrency in the design of Triveni, a framework for concurrent programming with threads and events. Triveni has been realized as JavaTriveni, a collection of tools for the Java programming language. We describe our experiences in JavaTriveni with an example from telecommunication.

   @inproceedings{DBLP:conf/coots/ColbyJJLP98,
     abbr = {COOTS},
     address = {Santa Fe, New Mexico, USA},
     author = {Colby, Christopher and Jagadeesan, Lalita Jategaonkar and Jagadeesan, Radha and Läufer, Konstantin and Puchol, Carlos},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 4th {USENIX} {Conference} on {Object}-{Oriented} {Technologies} and {Systems} ({COOTS})},
     month = apr,
     pages = {131--149},
     publisher = {USENIX},
     timestamp = {Tue, 02 Feb 2021 00:00:00 +0100},
     title = {Objects and {Concurrency} in {Triveni}: {A} {Telecommunication} {Case} {Study} in {Java}},
     url = {https://www.usenix.org/conference/coots-98/objects-and-concurrency-triveni-telecommunication-case-study-java},
     website = {https://www.usenix.org/conference/coots-98/objects-and-concurrency-triveni-telecommunication-case-study-java},
     year = {1998}
   }

3. ICCL

   Design and Implementation of Triveni: A Process-Algebraic API for Threads + Events

   Christopher Colby, Lalita Jategaonkar Jagadeesan, Radha Jagadeesan, and 2 more authors

   In Proceedings of the 1998 International Conference on Computer Languages (ICCL), May 1998

   Abs DOI Bib

   We describe Triveni, a framework and API for integrating threads and events. The design of Triveni is based on an algebra, including preemption combinators, of processes. Triveni is compatible with existing threads standards, such as Pthreads and Java threads, and with the event models structured on the Observer pattern. We describe the software architecture and algorithms underlying a concrete implementation of Triveni in Java. This environment includes specification based testing of safety properties. The results described in the paper have been used to integrate process-algebraic methods into (concurrent) object orientated programming (C. Colby et al., 1998).

   @inproceedings{DBLP:conf/iccl/ColbyJJLP98,
     abbr = {ICCL},
     address = {Chicago, IL, USA},
     author = {Colby, Christopher and Jagadeesan, Lalita Jategaonkar and Jagadeesan, Radha and Läufer, Konstantin and Puchol, Carlos},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 1998 {International} {Conference} on {Computer} {Languages} ({ICCL})},
     doi = {10.1109/ICCL.1998.674157},
     month = may,
     pages = {58--67},
     publisher = {IEEE Computer Society},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {Design and {Implementation} of {Triveni}: {A} {Process}-{Algebraic} {API} for {Threads} + {Events}},
     year = {1998}
   }

4. ENTCS

   The Semantics of Triveni: A Process-Algebraic API for Threads + Events

   Christopher Colby, Lalita Jategaonkar, Radha Jagadeesan, and 2 more authors

   Electronic Notes in Theoretical Computer Science, May 1998

   Abs DOI Bib

   This paper describes compositional semantics (operational, denotational and logical) for a process algebra enhanced with input/output actions and preemption combinators, in the presence of fairness. The context of this paper is Triveni, a process-algebra-based design methodology that combines threads and events in the context of object-oriented programming. Triveni has been realized as an Application Programmer Interface in the Java programming language. The semantics described in this paper forms the theoretical basis of the Triveni programming language and environment. (i) The operational model described in this paper is the precise formalization of the implementation. (ii) The denotational semantics serves as the basis for a non-definability result. This result justifies the introduction of certain powerful preemption combinators as primitives in Triveni. (iii) The logical semantics forms the basis of our specification-based testing environment realized in the implementation.

   @article{DBLP:journals/entcs/ColbyJJLP98,
     abbr = {ENTCS},
     author = {Colby, Christopher and Jategaonkar, Lalita and Jagadeesan, Radha and Läufer, Konstantin and Puchol, Carlos},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1016/S1571-0661(05)80233-6},
     journal = {Electronic Notes in Theoretical Computer Science},
     pages = {107--133},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {The {Semantics} of {Triveni}: {A} {Process}-{Algebraic} {API} for {Threads} + {Events}},
     volume = {14},
     year = {1998}
   }

1997

1. Using Java in the Undergraduate Computer Science Curriculum

   Konstantin Läufer

   Mar 1997

   Presented at the Eleventh Annual Midwest Computer Conference (MCC ’97)

   Bib

   @misc{Laufer_MCC_1997,
     address = {Springfield, IL, USA},
     author = {Läufer, Konstantin},
     month = mar,
     note = {Presented at the {Eleventh} {Annual} {Midwest} {Computer} {Conference} ({MCC} '97)},
     title = {Using {Java} in the {Undergraduate} {Computer} {Science} {Curriculum}},
     year = {1997}
   }

1996

1. POPL

   Putting Type Annotations to Work

   Martin Odersky, and Konstantin Läufer

   In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’96), Jan 1996

   Abs DOI Bib

   We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.

   @inproceedings{DBLP:conf/popl/OderskyL96,
     abbr = {POPL},
     address = {St. Petersburg Beach, Florida, USA},
     author = {Odersky, Martin and Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages} ({POPL} '96)},
     doi = {10.1145/237721.237729},
     editor = {Boehm, Hans-Juergen and Jr., Guy L. Steele},
     month = jan,
     pages = {54--67},
     publisher = {Association for Computing Machinery},
     timestamp = {Tue, 06 Nov 2018 00:00:00 +0100},
     title = {Putting {Type} {Annotations} to {Work}},
     year = {1996}
   }

2. JFP

   Type Classes with Existential Types

   Konstantin Läufer

   Journal of Functional Programming, Jan 1996

   Abs DOI Bib

   We argue that the novel combination of type classes and existential types in a single language yields significant expressive power. We explore this combination in the context of higher-order functional languages with static typing, parametric polymorphism, algebraic data types and Hindley–Milner type inference. Adding existential types to an existing functional language that already features type classes requires only a minor syntactic extension. We first demonstrate how to provide existential quantification over type classes by extending the syntax of algebraic data type definitions, and give examples of possible uses. We then develop a type system and a type inference algorithm for the resulting language. Finally, we present a formal semantics by translation to an implicitly-typed second-order λ-calculus and show that the type system is semantically sound. Our extension has been implemented in the Chalmers Haskell B. system, and all examples from this paper have been developed using this system.

   @article{DBLP:journals/jfp/Laufer96,
     abbr = {JFP},
     author = {Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     doi = {10.1017/S0956796800001817},
     journal = {Journal of Functional Programming},
     number = {3},
     pages = {485--517},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {Type {Classes} with {Existential} {Types}},
     volume = {6},
     year = {1996}
   }

3. An Open Environment for Common Gateway Interface Programming

   Konstantin Läufer

   Mar 1996

   Presented at the Tenth Annual Midwest Computer Conference (MCC ’96)

   Bib

   @misc{Laufer_MCC_1996,
     address = {Chicago, IL, USA},
     author = {Läufer, Konstantin},
     month = mar,
     note = {Presented at the {Tenth} {Annual} {Midwest} {Computer} {Conference} ({MCC} '96)},
     title = {An {Open} {Environment} for {Common} {Gateway} {Interface} {Programming}},
     year = {1996}
   }

4. On the Interaction of Object-Oriented Design Patterns and Programming Languages

   Gerald Baumgartner, Konstantin Läufer, and Vincent F. Russo

   Feb 1996

   Technical Report

   Abs arXiv Bib PDF

   Design patterns are distilled from many real systems to catalog common programming practice. However, some object-oriented design patterns are distorted or overly complicated because of the lack of supporting programming language constructs or mechanisms. For this paper, we have analyzed several published design patterns looking for idiomatic ways of working around constraints of the implementation language. From this analysis, we lay a groundwork of general-purpose language constructs and mechanisms that, if provided by a statically typed, object-oriented language, would better support the implementation of design patterns and, transitively, benefit the construction of many real systems. In particular, our catalog of language constructs includes subtyping separate from inheritance, lexically scoped closure objects independent of classes, and multimethod dispatch. The proposed constructs and mechanisms are not radically new, but rather are adopted from a variety of languages and programming language research and combined in a new, orthogonal manner. We argue that by describing design patterns in terms of the proposed constructs and mechanisms, pattern descriptions become simpler and, therefore, accessible to a larger number of language communities. Constructs and mechanisms lacking in a particular language can be implemented using paradigmatic idioms.

   @techreport{BaumgartnerLauferRusso_Interactions_1996,
     arxiv = {1905.13674},
     author = {Baumgartner, Gerald and Läufer, Konstantin and Russo, Vincent F.},
     institution = {Purdue University},
     month = feb,
     note = {Technical {Report}},
     number = {CSD-TR-96-020},
     pdf = {https://arxiv.org/pdf/1905.13674},
     title = {On the {Interaction} of {Object}-{Oriented} {Design} {Patterns} and {Programming} {Languages}},
     url = {https://arxiv.org/abs/1905.13674},
     year = {1996}
   }

1995

1. COOTS

   A Framework for Higher-Order Functions in C++

   Konstantin Läufer

   In Proceedings of the USENIX Conference on Object-Oriented Technologies (COOTS ’95), Jun 1995

   Abs Bib Website

   C and C++ allow passing functions as arguments to other functions in the form of function pointers. However, since function pointers can refer only to existing functions declared at global or file scope, these function arguments cannot capture local environments. This leads to the common misconception that C and C++ do not support function closures. In fact, function closures can be modeled directly in C++ by enclosing a function inside an object such that the local environment is captured by data members of the object. This idiom is described in advanced C++ texts and is used, for example, to implement callbacks. The purpose of this paper is twofold: First, we demonstrate how this idiom can be generalized to a type-safe framework of C++ class templates for higher-order functions that support composition and partial application. Second, we explore the expressiveness of the framework and compare it with that of existing functional programming languages. We illustrate by means of various examples that object-oriented and functional idioms can coexist productively and can be used to enhance the functionality of common classes, for example, of nonlinear collections such as trees. A C++ implementation of the framework is available on request.

   @inproceedings{DBLP:conf/coots/Laufer95,
     abbr = {COOTS},
     address = {Monterey, CA, USA},
     author = {Läufer, Konstantin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the {USENIX} {Conference} on {Object}-{Oriented} {Technologies} ({COOTS} '95)},
     editor = {Russo, Vincent F.},
     month = jun,
     publisher = {USENIX},
     title = {A {Framework} for {Higher}-{Order} {Functions} in {C}++},
     url = {https://www.usenix.org/conference/coots-95/framework-higher-order-functions-c},
     website = {https://www.usenix.org/conference/coots-95/framework-higher-order-functions-c},
     year = {1995}
   }

2. Interactive Web Applications Based on Finite State Machines (Invited Talk)

   Konstantin Läufer

   Aug 1995

   Presented at the Symposium on Information Systems Analysis and Synthesis (ISAS)

   Bib

   @misc{Laufer_ISAS_1995,
     address = {Baden-Baden, Germany},
     author = {Läufer, Konstantin},
     month = aug,
     note = {Presented at the {Symposium} on {Information} {Systems} {Analysis} and {Synthesis} ({ISAS})},
     title = {Interactive {Web} {Applications} {Based} on {Finite} {State} {Machines} ({Invited} {Talk})},
     year = {1995}
   }

1994

1. CLEI

   Combining Type Classes and Existential Types

   Konstantin Läufer

   In Proceedings of the Latin American Informatics Conference (PANEL ’94), Sep 1994

   Bib

   @inproceedings{Laufer_PANEL_1994,
     abbr = {CLEI},
     address = {Mexico},
     author = {Läufer, Konstantin},
     booktitle = {Proceedings of the {Latin} {American} {Informatics} {Conference} ({PANEL} '94)},
     month = sep,
     publisher = {CLEI},
     title = {Combining {Type} {Classes} and {Existential} {Types}},
     year = {1994}
   }

2. TOPLAS

   Polymorphic Type Inference and Abstract Data Types

   Konstantin Läufer, and Martin Odersky

   ACM Transactions on Programming Languages and Systems (TOPLAS), Sep 1994

   Abs DOI Bib PDF

   Many statically typed programming languages provide an abstract data type construct, such as the module in Modula-2. However, in most of these languages, implementations of abstract data types are not first-class values. Thus, they cannot be assigned to variables, passed as function parameters, or returned as function results. Several higher-order functional languages feature strong and static type systems, parametric polymorphism, algebraic data types, and explicit type variables. Most of them rely on Hindley-Milner type inference instead of requiring explicit type declarations for identifiers. Although some of these languages support abstract data types, it appears that none of them directly provides light-weight abstract data types whose implementations are first-class values. We show how to add significant expressive power to statically typed functional languages with explicit type variables by incorporating first-class abstract types as an extension of algebraic data types. Furthermore, we extend record types to allow abstract components. The components of such abstract records are selected using the dot notation. Following Mitchell and Plotkin, we formalize abstract types in terms of existentially quantified types. We give a syntactically sound and complete type inference algorithm and prove that our type system is semantically sound with respect to standard denotational semantics.

   @article{DBLP:journals/toplas/LauferO94,
     abbr = {TOPLAS},
     author = {Läufer, Konstantin and Odersky, Martin},
     doi = {10.1145/186025.186031},
     journal = {ACM Transactions on Programming Languages and Systems (TOPLAS)},
     number = {5},
     pages = {1411--1430},
     pdf = {https://dl.acm.org/doi/pdf/10.1145/186025.186031},
     timestamp = {Thu, 14 Oct 2021 01:00:00 +0200},
     title = {Polymorphic {Type} {Inference} and {Abstract} {Data} {Types}},
     volume = {16},
     year = {1994}
   }

1993

1. OOPSLA

   Self-Interpretation and Reflection in a Statically Typed Language

   Konstantin Läufer, and Martin Odersky

   In Proceedings of the OOPSLA Workshop on Reflection and Metalevel Architectures, Oct 1993

   Abs Bib PDF

   Reflection is the ability of a system to perform a computation about itself. This ability typically includes a way of representing programs as data (“reification”) and of executing representations of programs (“self-interpretation”). The interpreter is accessible to the interpreted program in the form of an “eval” function. Reflection is traditionally studied in untyped or dynamically typed languages such as LISP [4] [2], Smalltalk [3], or the λ-calculus [9]. By contrast, we consider self-interpretation and reflection in a statically typed metalanguage along the lines of [10] and [7]. Since the language is statically typed, the data structure used as a representation for programs is statically typed as well. Reflection in a statically typed context can be characterized as follows: Type-preserving representation: If a representation is well-typed, then the represented pro gram is well-typed. Type-preservation of self-interpretation: A representation of a program of some type is re duced to a representation of the result of the program of the same type. Reuse: Features of the metalanguage, for instance the type checker or garbage collector, are re used directly without reprogramming them. A lack of reuse is called redundancy. Static typing in reflective systems is useful since it precludes breaches of type safety through self-interpretation; we cannot construct a syntax tree that causes a run-time type error when we interpret it. This goal is captured by the principle that the interpreted program should be as safe as the original one.

   @inproceedings{LauferOdersky_Reflection_1993,
     abbr = {OOPSLA},
     address = {Washington, DC, USA},
     author = {Läufer, Konstantin and Odersky, Martin},
     booktitle = {Proceedings of the {OOPSLA} {Workshop} on {Reflection} and {Metalevel} {Architectures}},
     month = oct,
     pdf = {Laufer\_Reflection\_1993.pdf},
     publisher = {Association for Computing Machinery},
     title = {Self-{Interpretation} and {Reflection} in a {Statically} {Typed} {Language}},
     year = {1993}
   }

1992

1. ML

   An Extension of ML with First-Class Abstract Types

   Konstantin Läufer, and Martin Odersky

   In Proceedings of the ACM SIGPLAN Workshop on ML and its Applications, Jun 1992

   Abs Bib PDF

   Many statically-typed programming languages provide an abstract data type construct, such as the package in Ada, the cluster in CLU, and the module in Modula2. In these languages, an abstract data type consists of two parts, interface and implementation. The implementation consists of one or more representation types and some operations on these types; the interface specifies the names and types of the operations accessible to the user of the abstract data type. ML [MTH90] provides two distinct constructs for describing abstract data types: • The (obsolete) abstype mechanism is used to declare an abstract data type with a single implemen tation. It has been superseded by the module system. • The ML module system provides signatures, structures, and functors. Signatures act as interfaces of abstract data types and structures as their implementations; functors are essentially parametrized structures. Several structures may share the same signature, and a single structure may satisfy several signatures. However, structures are not first-class values in ML for type-theoretic reasons discussed in [Mac86] [MH88]. This leads to considerable difficulties in a number of practical programming sit uations. Mitchell and Plotkin show that abstract types can be given existential type [MP88]. By stating that a val ue v has the existential type , we mean that for some fixed, unknown type , has type . This paper presents a semantic extension of ML, where the component types of a datatype may be existentially quantified. We show how datatypes over existential types add significant flexibility to the language without even changing ML syntax; in particular, we give examples demonstrating how we express • first-class abstract types, • multiple implementations of a given abstract type, • heterogeneous aggregates of different implementations of the same abstract type, and • dynamic dispatching of operations with respect to the implementation type. We have a deterministic Damas-Milner inference system [DM82] [CDDK86] for our language, which leads to a syntactically sound and complete type reconstruction algorithm. Furthermore, the type system is semantically sound with respect to a standard denotational semantics. Most previous work on existential types does not consider type reconstruction. Other work appears to be semantically unsound or does not permit polymorphic instantiation of variables of existential type. By con trast, in our system such variables are let-bound and may be instantiated polymorphically. We have implemented a Standard ML prototype of an interpreter with type reconstruction for our core language, Mini-ML [CDDK86] extended with recursive datatypes over existentially quantified component types. All examples from this paper have been developed and tested using our interpreter

   @inproceedings{LauferOdersky_ML_1992,
     abbr = {ML},
     address = {San Francisco, CA, USA},
     author = {Läufer, Konstantin and Odersky, Martin},
     booktitle = {Proceedings of the {ACM} {SIGPLAN} {Workshop} on {ML} and its {Applications}},
     month = jun,
     pdf = {https://publikationen.bibliothek.kit.edu/368396/774466/},
     publisher = {Association for Computing Machinery},
     title = {An {Extension} of {ML} with {First}-{Class} {Abstract} {Types}},
     year = {1992}
   }

2. Polymorphic Type Inference and Abstract Data Types

   Konstantin Läufer

   Jul 1992

   PhD Thesis

   Abs Bib PDF

   Many statically-typed programming languages provide an abstract data type construct, such as the package in Ada, the cluster in CLU, and the module in Modula2. However, in most of these languages, instances of abstract data types are not first-class values. Thus they cannot be assigned to a variable, passed as a function parameter, or returned as a function result. The higher-order functional language ML has a strong and static type system with parametric polymorphism. In addition, ML provides type reconstruction and consequently does not require type declarations for identifiers. Although the ML module system supports abstract data types, their instances cannot be used as first-class values for type-theoretic reasons. In this dissertation, we describe a family of extensions of ML. While retaining ML’s static type discipline, type reconstruction, and most of its syntax, we add significant expressive power to the language by incorporating first-class abstract types as an extension of ML’s free algebraic datatypes. In particular, we are now able to express multiple implementations of a given abstract type; heterogeneous aggregates of different implementations of the same abstract type; and dynamic dispatching of operations with respect to the implementation type. Following Mitchell and Plotkin, we formalize abstract types in terms of existentially quantified types. We prove that our type system is semantically sound with respect to a standard denotational semantics. We then present an extension of Haskell, a non-strict functional language that uses type classes to capture systematic overloading. This language results from incorporating existentially quantified types into Haskell and gives us first-class abstract types with type classes as their interfaces. We can now express heterogeneous structures over type classes. The language is statically typed and offers comparable flexibility to object-oriented languages. Its semantics is defined through a type-preserving translation to a modified version of our ML extension. We have implemented a prototype of an interpreter for our language, including the type reconstruction algorithm, in Standard ML.

   @phdthesis{Laufer_Thesis_1992,
     author = {Läufer, Konstantin},
     key = {lau92},
     month = jul,
     note = {{PhD} {Thesis}},
     pdf = {Laufer\_Thesis\_1992.pdf},
     school = {New York University},
     title = {Polymorphic {Type} {Inference} and {Abstract} {Data} {Types}},
     year = {1992}
   }

1991

1. PHOENIX

   Type Classes are Signatures of Abstract Types

   Konstantin Läufer, and Martin Odersky

   In Proceedings of the 1991 PHOENIX Seminar and Workshop on Declarative Programming, Nov 1991

   Abs DOI Bib

   We present an extension of Haskell’s type class concept in which a type class is identified with the signature of an abstract type As shown by Mitchell and Plotkin, abstract types can be expressed using existential quantification. Unlike in Mitchell and Plotkin’s work, an abstract type does not come with one — and only one — implementation. Rather, any concrete type can be declared to be an implementation by a clause that corresponds to an instance declaration in Haskell. We introduce F-bounded existential quantification, where an abstract type has the form: }E a . C(α) . τ(α) Here, C(α) is a set of constraints that restricts the range of the bound variable α, and τ(α) is a type constructed from α. The expression reads “some type τ(α), where α is some arbitrary fixed type satisfying constraints C(α)”. The constraint set C corresponds to a type class. Just like a type class, it contains declarations for overloaded identifiers as well as conformity clauses that declare one abstract type to be more specific than another. The generalization of type classes to abstract types has the advantage of greater expressiveness: We can model polymorphic abstract types and heterogeneous data structures, concepts which cannot be expressed in Haskell. An example of a polymorphic abstract type is ∀α.Bag α, the abstract type of all bags with elements of type α. In Haskell, we would either have to fix the element type, or we would have to fix the implementation of Bag. Our extension shares the desirable properties of the type class approach in that it is fully static and in that type reconstruction is feasible.

   @inproceedings{DBLP:conf/phoenix/LauferO91,
     abbr = {PHOENIX},
     address = {Sasbachwalden, Germany},
     author = {Läufer, Konstantin and Odersky, Martin},
     bibsource = {dblp computer science bibliography, https://dblp.org},
     booktitle = {Proceedings of the 1991 {PHOENIX} {Seminar} and {Workshop} on {Declarative} {Programming}},
     doi = {10.1007/978-1-4471-3794-8_10},
     editor = {Darlington, John and Dietrich, Roland},
     month = nov,
     pages = {148--162},
     publisher = {Springer},
     series = {Workshops in {Computing}},
     timestamp = {Fri, 21 Jun 2019 13:08:59 +0200},
     title = {Type {Classes} are {Signatures} of {Abstract} {Types}},
     year = {1991}
   }

2. CLEI

   Programming with Structures, Functions, and Objects

   Fritz Henglein, and Konstantin Läufer

   In Proceedings of the XVII Latin American Informatics Conference (PANEL ’91), Nov 1991

   Bib

   @inproceedings{HengleinLaufer_PANEL_1991,
     abbr = {CLEI},
     address = {Caracas, Venezuela},
     author = {Henglein, Fritz and Läufer, Konstantin},
     booktitle = {Proceedings of the {XVII} {Latin} {American} {Informatics} {Conference} ({PANEL} '91)},
     pages = {333--352},
     publisher = {CLEI},
     title = {Programming with {Structures}, {Functions}, and {Objects}},
     year = {1991}
   }

3. Three Approaches to Transformational Programming – A Comparative Survey

   Konstantin Läufer

   Apr 1991

   Technical Report

   Abs Bib PDF

   Transformational programming is a methodology that intends to formalize the development of programs from problem speci cations. Given the recent e ort towards the design of a common prototyping system (CPS) for the Ada programming language, transformation systems may be reconsidered as possible components of prototyping systems. This paper examines and evaluates three approaches to transformational programming: - The Munich CIP project (Computer-aided, Intuition-guided Programming) consists of a strongly typed, wide-spectrum language with user-de ned algebraic types and a semi automatic transformation system that requires user guidance. - By contrast, }Algorithmics," the work on algebraic speci cation originating from IFIP WG 2.1, is a pure pencil-and-paper approach to transformational programming. It provides a concise, uniform mathematical notation and includes work on nondeterminism. - RAPTS (Robert A. Paige’s Transformation System) is a fully mechanical system that transforms high-level speci cations to C code. The speci cations are given in a functional subset of SETL augmented with fixed-point operations.

   @techreport{Laufer_Transformational_1991,
     author = {Läufer, Konstantin},
     institution = {Department of Computer Science, New York University},
     month = apr,
     note = {Technical {Report}},
     number = {NYU-CS-TR 555},
     pdf = {Laufer\_Transformational\_1991.pdf},
     title = {Three {Approaches} to {Transformational} {Programming} – {A} {Comparative} {Survey}},
     year = {1991}
   }

1987

1. Cobra Address User Manual

   Konstantin Läufer, and Wolfgang Mehl

   Apr 1987

   Technical Report

   Bib

   @techreport{laufer1987,
     address = {Technologiezentrum Konstanz, Germany},
     author = {Läufer, Konstantin and Mehl, Wolfgang},
     institution = {Cobra GmbH},
     note = {Technical {Report}},
     title = {Cobra {Address} {User} {Manual}},
     year = {1987}
   }

1986

1. Cobra Litsy User Manual

   Konstantin Läufer

   Apr 1986

   Technical Report

   Bib

   @techreport{laufer1986,
     address = {Technologiezentrum Konstanz, Germany},
     author = {Läufer, Konstantin},
     institution = {Cobra GmbH},
     note = {Technical {Report}},
     title = {Cobra {Litsy} {User} {Manual}},
     year = {1986}
   }

1984

1. MailBox User Manual and Administration Guide

   Ralf Dierenbach, Heinz-Erich Erbs, and Konstantin Läufer

   Apr 1984

   Technical Report

   Bib

   @techreport{laufer1984,
     author = {Dierenbach, Ralf and Erbs, Heinz-Erich and Läufer, Konstantin},
     institution = {Universität Konstanz},
     note = {Technical {Report}},
     title = {{MailBox} {User} {Manual} and {Administration} {Guide}},
     year = {1984}
   }