Dear SoSyM readers, it is our pleasure to introduce the first SoSyM issue of 2026.As is customary, this opening issue includes an editorial offering an annual overview of the journal's current status and the changes in the editorial board and technology.The past year has been productive, with the publication of numerous new SoSyM articles, special sections, and ongoing initiatives within our editorial team.The launch of our new 2024 publication format dedicated to modeling tools has led to the first three tool-focused publications, which are already available online.The first one, namely, "The MDENet education platform: zero-install directed activities for learning MDE" by Steffen Zschaler, Will Barnett, Artur Boronat, Antonio Garcia-Dominguez, and Dimitris Kolovos is already included in this issue.Two more will follow in the next issues.We would like to thank Jordi Cabot and Abel Gómez for organizing this tool paper format.As may be expected when introducing a new format, the number of incoming papers is slowly but steadily B

Model-Based Software Engineering (MBSE) has matured into a rich ecosystem of methods and tools that support the systematic design, analysis, and evolution of complex systems.Model-Based Systems Engineering (MBSysE) is now following a similar trajectory, building on the advances of MBSE.Over the past decades, we have developed ways to encode our understanding in models, to formalize designs, and to automate transformation and validation steps.In contrast, the recently emerged Agentic AI enables the development of autonomous AI systems that can perceive, reason, plan, and act independently.Such systems can pursue complex goals with minimal human oversight, moving beyond simple command-response interactions to proactively leverage external tools.In this setting, AI agents exhibit agency: They demonstrate goal-driven behavior and can execute multi-step tasks.In software, and more broadly, systems development projects, such AI agents can be viewed as junior, or even senior, developers capable of executing substantial tasks.This creates both a challenge and an unprecedented opportunity for MBSE.At present, it remains unclear whether agentic AI can reliably translate informal, high-level requirements into correctly designed, implemented, and validated systems.The end-to-end process is long, and the risk of hallucinations or other incorrect actions remains significant.

A common understanding of ontologies is that an ontology is a structured framework used to organize information and knowledge in a specific domain.It defines concepts, categories, properties, and relationships in a way that both humans and computers can understand.Typical ontological components include concepts (or classes), instances (or individuals), properties describing characteristics, and relationships between concepts as well as between instances (e.g., a "Person" has a "birthdate" and "Konrad Zuse" is an instance of "Person" and has his birthdate on "June, 22").Practical applications demonstrate that ontologies can be successfully used in a variety of domains, such as artificial intelligence, the semantic web, enterprise architecture, or information retrieval, often in the form of knowledge graphs.This makes them particularly attractive when the goal is to capture, share, and reason about domain knowledge.When comparing the language constructs, the ontology approach is very closely related both to UML class diagrams and to MOF-based metamodels.However, in both cases expressibility, but in particular their purposes differ to a large extent.It is therefore worthwhile to compare both individually.

This Idea Paper examines the benefits and tooling support needed to introduce testing concepts to younger students. Unit testing typically involves comparing the expected and actual values of a program's results. Traditionally, the comparison is performed on primitives like numbers and strings, or a specific object's state. However, in a Blocks-Based Programming Language (BBPL) like Scratch, which is often used to introduce younger students to programming concepts, the output is often graphical. Thus, there is a need to compare the results from the visual output. The shift from textual to visual assessment highlights the need for methods to evaluate the visual output produced by Scratch programs. Influenced by concepts from traditional unit testing frameworks, our approach focuses on simple testing capabilities in Scratch projects, particularly those with visual outputs. This Idea Paper introduces our graphical comparison method and a supporting tool to evaluate the behavior of Scratch programs. Our approach involves comparing two-dimensional (2D) images representing the expected and actual output after execution of a Scratch program. We performed an initial experiment of our unit testing tool using Scratch programs available from creativeprogramming.org, a platform that hosts an international Scratch Olympiad competition for students of various ages. We present the initial results of evaluating our approach with student projects from this platform, demonstrating how our approach can serve as an initial effort at introducing testing into programming environments that support younger students. We also discuss how such a tool can be used to assist teachers with autograding of Scratch programs.

As we present this issue of the Journal of Software and Systems Modeling (SoSyM), we take a moment to acknowledge and celebrate the remarkable contributions of Professor Antonio Vallecillo.After decades of dedication to the field, Antonio is now retiring, leaving behind an impressive amount of results in software and systems modeling.He has been a cornerstone of our journal, serving as an editor almost from the very beginning of SoSyM's 25 year journey.He was always helpful as editor, advisor, and friend.His expertise, vision, and continuous commitment have significantly shaped not only the special section presented in this issue, but also the broader research community.Antonio has played a long lasting and pivotal role in advancing the journal's mission, ensuring the highest standards of quality in published research, and fostering a strong sense of collaboration among researchers.His influence extends well beyond SoSyM; he has been a driving force in the development of modeling techniques, particularly in the domains of cyber-physical systems (CPSs), uncertainty B Benoit Combemale

Dear SoSyM readers

Software and Systems Modeling (SoSyM) is a journal dedicated to advancing the field of software and systems modeling by publishing high-quality research that contributes to the theory and practice of modeling in software and systems engineering, which also includes processes executed automatically or involving humans.The journal aims to bridge the gap between academia and industry by fostering discussions on modeling languages, methodologies, tools, and their applications to real-world challenges.SoSyM encourages submissions that present innovative modeling approaches, their precise semantic foundations, empirical evaluations, and applications that have tangible impacts on software and system development processes.Given this mission, the journal welcomes research on formal methods, provided that such work is framed within the context of software and systems modeling.Formal methods, as mathematically rigorous techniques for specifying, developing, and verifying software and systems, undoubtedly have significant potential to enhance modeling practices.However, the focus of SoSyM is not formal methods in isolation but rather their role and contribution to the field of software and systems modeling.Thus, a manuscript that centers on a formal method must explicitly articulate its relevance to software and systems modeling.This means that a submission should not merely B

Software developers often need to manage dependencies.Unfortunately, software dependencies manifest themselves in various forms, and discussions about dependencies can be challenging due to the very different definitions and relationships that developers may have in mind.To reduce misunderstandings, it may be helpful to categorize the various forms of dependencies.A dependency is a relationship between two (or more) different things.Let us exclude relationships with more than two participants and concentrate on binary relations to simplify considerations.During a typical development process, dependencies may emerge across all forms of artifacts, including requirement statements, explicit models, source code, and (readily compiled and deployable) system elements.To be precise, we distinguish development artifacts (which include, e.g., UML/SysML models and source code) and the system elements.For example, an object-oriented system consists of implemented classes and their (logical) aggregations in the form of subsystems and components.System elements are to be distinguished from models and source code, which aggregate into packages, directories, branches, or even (version-controlled) projects.Both sides, i.e., the system and the artifacts describing it, are not entirely independent of each other.Java, in particular, has done a tremendous job reliably connecting classes and their source files in an almost one-to-one relation.Colloquially, we thus do not need to distinguish between a class and its describing source file anymore.However, in this article we mention these two sides because the term "dependency" is used within both sides.Projects depend on each other; components depend on each other; and models depend on each other.

There are important standardization bodies that actually create very good and widely used standards in engineering and development.This is prominent in other engineering domains, but less common in computer science.We may speculate about the reasons, but it may be that computer science is relatively young, and therefore, techniques and methods evolve frequently, and standards may hinder this form of innovation.A second reason may be that in computer science, large companies are developing the de facto standards that are not necessarily becoming formal standards.But in computer science, standards also ensure compatibility, interoperability, reliability, security, reusability, and potentially many other good properties across services, applications, systems, and technologies.And we all know some key categories and examples of relevant standards, such as programming language standards (e.g., ISO/IEC 9899-for C, Java Community Process (JCP) specs-for Java, ECMA-262/ISO/IEC 16262-for JavaScript, HTTP/HTTPS (RFC 9110) protocol-for web communication, and RFC 8259-for JSON).The most relevant standards for Software & Systems Engineering are UML (first by the OMG and later by ISO/IEC 19505), IEEE 830 / ISO/IEC/IEEE 29148-for Software Requirements Specification, and the newly emerging standards around the digital twin technologies stack that are in discussion by the Digital Twin Consortium (DTC) and the Industrial Digital Twin Association (IDTA).As a side note, B

In recent discussions, a recurring theme has been the evolving role of specification languages in industrial practice.While formal methods and modeling languages have long aspired to provide unified frameworks for reasoning about software systems, contemporary usage patterns-particularly in largescale industrial settings such as big tech companies-paint a different picture.In several big tech companies, and potentially in other software-intensive businesses, specification exists almost entirely in the service of verification.If a specification does not directly enable the formal verification of an artifact of practical importance-such as code, APIs, configurations, protocols, or policies-it is deemed irrelevant.This perspective frames specification not as an abstraction layer or design blueprint, but as a tightly coupled tool for reasoning about concrete, existing system artifacts.The implications are far-reaching.First, languages are chosen not for their generality or unification power, but rather for their precision and fitness for a specific verification task.They specify specific artifacts, e.g., configuration or orchestration of specific tasks.Task plans are then integrated using sophisticated and consistency-verifying tools.Often, this means designing small domain-specific languages (DSLs) that restrict certain forms of expressiveness, but in B

Blocks-based programming languages (BBPLs) are widely used for their visual approach, particularly in educational settings [1]. However, testing graphical outputs in these languages presents unique challenges that traditional unit testing does not adequately address [3]. Traditional unit tests focus on verifying textual or numerical results, which is insufficient for the visual nature of BBPLs [5, 7].

Blocks-based programming languages (BBPLs) have proven effective for instructing early learners in programming. Unlike text-based languages, BBPLs eliminate the need to memorize syntax rules by enforcing correct program structure through block assembly. However, the visual nature of BBPLs can pose challenges for children with visual impairments and blindness (VI). Moreover, the existing BBPLs tailored for children with VI are rarely embraced by sighted children due to their limited capabilities. To explore the creation of an inclusive BBPL that can be used by both children with and without VI, we devised a web-based BBPL platform with keyboard accessibility functionalities and personalized audio cues through an incorporated screen reader. Within this platform, called Grid-world, students engage with basic programming concepts, including iteration and selection, through entertaining games and animations-such as navigating a character within a 2D grid space. Notably, Grid-world accommodates children with VI without the need for extra hardware or assistive devices. We conducted two empirical assessments of Grid-world involving participants with and without VI. The observational analysis of participant interaction and survey responses illuminated areas for enhancement. We describe the rationale behind Grid-world's design and accessibility features, incorporating findings from experimental studies, including participants' feedback on the accessibility features.

International audience

International audience

International audience

International audience

effort to develop a framework for defining the most pressing Sustainable Development Goals B

International audience

International audience

At the end of September 2022 at RWTH Aachen, Germany, there was a meeting attended by several experts on software language development with a specific emphasis on modeling.The LangDev meetings are particularly dedicated to the exchange of new ideas and innovations around the definition and use of Domain-Specific Languages (DSLs).Developers and users from multiple research and tooling groups attended, including representation from Essential, Freon (formerly ProjectIT), Gemoc, Langium, LinGo, MontiCore, MPS, Rascal, SpooFax, StarLasu, and Stratego.Attendees presented and discussed new trends and developments in their domains.Several practitioners also demonstrated new applications and uses of DSLs in various application domains, ranging from the European Union Digital COVID(-19) Certificate (the EU Digital Covid Certificate), to industrial printing systems, and digital twins, to name a few.LangDev 22 presented a very good balance among practitioners and researchers, as well as industrial and academic partners.The meeting welcomed a large number of new and young participants, which is a good sign for the community.Industrial partners included language workbench providers, and language workbench users, with impressive applications ranging from the EU DCC to examples in scientific computing.As the theme for this editorial, we want to share our impressions from that meeting as well as some general observations.The diversity of language definition approaches appear to be more diverse, yet harmonize in the concepts available.Several techniques created originally in one technology stack are now adopted in other tooling platforms.It is also evident that various approaches are moving to the web, which B

Improving active participation during enterprise operations modeling with an extended story-cardmethod and participative modeling software" by Marne de Vries and Petra Opperman ◯ "Gamifying model-based engineering: The PapyGame experience" by Antonio Bucchiarone,

International audience

International audience

The inaugural issue of each SoSyM volume-year is usually written during a time of personal and professional reflection.Over the past 12 months, researchers from all disciplines continued to experience the need for flexibility as the COVID-19 pandemic extended its impact across the globe through many variants.This has forced us all to adapt in many ways such that the idea of "virtual everything" permeates our daily discussions.The software and systems modeling community continued to thrive and exhibited a great degree of flexibility and increased production in the overall research output, despite the limitations for in-person collaborations.In fact, for many years, the first issue of each SoSyM volume-year has reported growth in submissions and other important metrics.The same is true for the 2021 publication year of SoSyM.The journal continues a positive and healthy trajectory in the increased number of submissions and an impact factor that ranks SoSyM among the top publication venues for software engineering.The following sections report on various statistics and general updates about SoSyM that occurred over 2021.We invite all authors to continue submitting their contributions to SoSyM, and we are always available to correspond regarding questions about the suitability of an idea or potential submission.We wish you all of the best for a productive and satisfying year of research and personal growth in 2022!

a historical perspective on ATL versus Java based on complexity and size" by Stefan

Although modeling is used in almost all science and engineering disciplines, the explicit definition of modeling languages is an invention of modern computing technology.It was necessary to define modeling languages precisely so that computers could process the models described in the languages, as a way to support various analysis and synthesis needs (e.g., model analysis and code generation).However, these were not the first languages that were defined precisely.Natural languages, for example English in the Oxford dictionary and German in the Duden, received a rather formal definition prior to digital automation with computers.The ideas of grammars and related lexicographic definitions were transferred from the natural language context to the first computer languages, namely programming languages and specification languages, where it received much more precision.And for diagrammatic modeling languages, the concept of a meta-model was popularized, often as a variant of a class diagram.The precise definition of modeling languages allows us to make models explicit.The advantages of precise modeling languages are well-known, namely (E1) support for syntactically concise descriptions, (E2) attachment of precise semantics, (E3) a human-readable representation that provides a language summary, (E4) models defined by a language can be processed by computers to help identify inconsistencies, incompleteness, and other issues, and also (E5) provide the foundation for high-level analysis techniques as promoted in various forms by the formal methods community.Finally of course, other benefits also include constructive use, including (E6) automatically deriving code, tests, and related artifacts from the models, and (E7) the ability to interpret a model.

For a 2012 editorial [1], the relationships between modeling and programming languages were discussed.A decade later, it seems appropriate to revisit this issue because there is still not a widely accepted consensus on the main purpose of modeling languages and their models in software development.In this editorial, we highlight the most important aspects when identifying commonalities and differences between modeling and programming languages.We are fully aware that a detailed examination of all these relationships, properties, and their interdependencies is far beyond this short reflection.An important property of a program is its ability to be executed.Many models are also created with executability in mind.An executable model must incorporate all relevant aspects, including structure and behavioral properties, such that a code generator or interpreter can derive executable code from the model.However, models sometimes also serve different purposes that programming languages do not handle well or not at all, which is why modeling languages for software development are needed.Abstraction is often better served by appropriate modeling languages, where abstraction mechanisms are part of the language and defined within the model.Examples are superstate, sub-state mechanisms in Statecharts, or simulation relations between Statecharts, or logical implication that can be applied as a refinement relation between logical formulae, such as preconditions or invariants.Programming languages mainly concentrate on super/sub-classes in object-oriented languages when introducing abstraction mechanisms.Along with abstraction, an important need is the ability or even necessity to specify structural and behavioral properties that are not directly executable.Underspecification is an intrinsic abstraction concept that programming languages do B

In 2020, over 116,000 students took the Advanced Placement Computer Science Principles (AP CSP) Exam. Although Black female students have participated in AP CSP at higher rates than for the AP CSA course, their representation is still disproportionately lower than the school population of Black females. In this Experience Report, we present the early results of an NSF-sponsored effort that provides an AP CSP preparatory experience and CS career awareness to Black female students from rural, urban, and suburban communities in the state of Alabama.

The growing interest in teaching Computer Science (CS) to K-12 students has led to the development of blocks-based programming languages (BBPLs) for young students where a program can be created by connecting blocks in a structured way. One of the benefits of a BBPL is removing the necessity to recall the syntax rules of a language. However, the visual nature of these languages makes learning and creating code difficult for children with visual impairments and blindness (VIB). Although a few BBPLs were designed for children with VIB, such environments are rarely used by sighted children. Therefore, to investigate the requirements for designing and implementing an accessible blocks-based programming environment that can be used by both students with and without VIB, we developed a BBPL environment for middle school children. The environment consists of a two-dimensional grid where a character can be moved by creating a simple blocks program. Our future plans include performing several empirical experiments to evaluate our BBPL, including the educational impact of the environment on all students and accessibility support for students with VIB. To perform the study, we also plan to prepare lessons for training the students. The results of the study will inform the design of future BBPL environments, as well as contribute toward broadening participation in computing by enabling children with visual impairments to participate fully in CS education opportunities.

Bad smells are indications of poor designs that decrease the quality and maintainability of software. Compared with extensive research on bad smells in the context of Object-Oriented Programming (code smells), bad smells in systems models (model smells) need much more investigation. Although some works have proposed several model smells in a few modeling domains, the understanding and perception of different types of model smells may vary due to depth of knowledge and area of expertise. To fill this gap, we conducted an empirical study to evaluate the model smells summarized in the existing literature within the context of LabVIEW systems models through an anonymous online survey. Based on the 45 complete responses received from a diverse group of systems modelers, we observed that there exist differences regarding the perception of various model smells. Furthermore, depth of knowledge (experienced and inexperienced users) was observed as a factor that affects a user's understanding of different model smells. However, area of expertise (academia/industry, as well as domain of focus) did not show significant difference in model smells perception. Moreover, we identified additional model smells from this empirical study. In this paper, we provide several recommendations to avoid common model smells and we summarize the lessons learned from this investigation. Our exploratory research provides empirical evidence that drives deeper insights into model smells and lays out recommendations to practitioners on how to avoid some of the prominent smells, thus improving the quality of software artifacts in systems models.

When writing the "2019 State of the Journal Report" at this same time last year, we could not have predicted the global changes that would beset us with so many challenges from the emergence of the COVID-19 pandemic.Some of us lost loved ones, friends, and colleagues, while the entire world adapted to working from home, participating in remote classrooms, and adopting safety precautions as a new means of daily life.The research community was also affected, with the cessation of travel leading to virtual conferences.Thanks to the heroic efforts of many conference chairs 1 adapting to the quick pace of change, scientific discussions continued, but sometimes in a less personable form.Journals also experienced changes with submissions on the rise, but fewer reviewers available to assist with the evaluation because of personal challenges faced by many.Yet, in the presence of a global pandemic, scientific contributions continued in the software and systems modeling community.The number of SoSyM submissions over the past year saw an increase, while the general health of the journal remains strong.Measures put in place recently, such as the second year of moving to six issues per year, have helped to reduce the time to publication significantly.The Open Access movement is also progressing, with Springer announcing new initiatives to make SoSyM publications more accessible to a broader community of researchers.The rest of this editorial summarizes the progress made by the journal during this unprecedented situation.Our hope is that you remain safe and have a productive 2021!

In October 2021, the workshop on Domain-Specific Modeling (held at the SPLASH conference series) celebrates its twentieth anniversary since the first workshop in 2001 (http:/

The recent surge in computer science (CS) education for children has led to the popularization of blocks-based programming languages (BBPLs), which offer a syntax-directed approach to teach fundamental programming concepts. Most BBPL environments are designed with imperative programming in mind. The primary building blocks represent the key constructs that support sequencing, iteration, and selection, all in an imperative style. Some BBPL environments support bi-directionality and can show the source code of the same program represented as either blocks or in a general-purpose textual language. There have been few alternatives to the imperative primitives used in these environments. In this Vision paper, we propose a paradigmatic change to the underlying and front-facing structures of BBPL environments by replacing them with Model-driven Engineering (MDE) primitives, such as declarative transformation rules and metamodels. We have implemented a prototype of our envisioned system in a modeling environment to show the feasibility of the approach, which we believe could be used by young children. The contribution of our vision is a demonstration of the potential for a new thread of research that lies at the intersection of modeling and CS education for children. We aim to spark an interest in MDE among CS education researchers, while encouraging the modeling community to consider how MDE might be taught to younger students.

The surge of interest in K-12 computer science (CS) over the past decade has led to a deep need for a corresponding expansion of trained teachers. The primary focus of most K-12 CS teacher professional development has been for current in-service teachers who have little background in CS. To raise the importance of CS within Colleges of Education, we believe that new pathways and experiences are needed for pre-service Education majors to learn more about authentic CS topics and pedagogy. This experience report summarizes our efforts over the past two years to prepare Secondary Math Education (SEMA) majors to teach AP CS Principles (AP CSP). Our approach consists of the following curricular activities: 1) a two-course sequence, with the first course mapping to the content topics of the AP CSP Curriculum Framework, and the second course consisting of a reflection of CS methods and pedagogy, including opportunities for SEMA students to develop and present their own AP CSP lesson plans; 2) opportunities for SEMA students to observe AP CSP classrooms in local high schools through our partnership with experienced AP CSP teachers; 3) summer participation in a College Board AP Summer Institute for AP CSP, and 4) a six-week ETS Praxis CS preparation modules-based course, offered to both pre-service SEMA students and in-service teachers. We summarize our lessons learned and present results that suggest our approach is preparing pre-service students with pedagogical and content knowledge that meets or exceeds current in-service training models (including an analysis of recent Praxis results for CS certification in our state).

The expansion of K-12 computer science (CS) has driven a dramatic need for educators who are trained in CS content and pedagogy [1]. This poster describes our effort to train teacher candidates (i.e., pre-service teachers who are students seeking degrees within a College of Education), who are specializing in secondary mathematics education, to be future CS educators. We specifically describe our collaboration to provide a blended preparatory six-week training for the ETS CS Praxis exam (5652), assisting our pre-service students in satisfying the CS certification requirements in our state before they graduate and begin their professional teaching career. Given the unique challenges of pre-service CS teacher preparation [2], blended models, which combine both in-person and online instruction, are an effective approach to building a pre-service program. Within our pre-service CS program, students first complete a two-course pathway that prepares them in AP CSP content and pedagogy experiences, including observations in local AP CSP classrooms [3]. After completing the two courses, our students participate in the blended version of the WeTeach_CS Praxis preparation course to achieve certification. The in-person support provided by the blended model contributed significantly to certification success in this project. With a cut-score of 149 for the Praxis exam, all 11 of our pre-service students who completed the course received a passing score (including one student with a perfect score of 200, and another student with a 195); the average score for our pre-service students was 175. An additional 11 in-service teachers, with diverse backgrounds in CS content knowledge, also participated in the blended Praxis preparation course, with an average score of 166. Given the unique challenges of pre-service CS teacher preparation, university pre-service CS teacher programs should look to innovative models of teacher support developed by in-service programs to make substantial gains in CS teacher certification. Incorporating an asynchronous online course that allows teachers with a wide range of prior experience in CS to learn at their own pace with in-person coursework and support appears to be a viable model for assisting non-CS major teacher candidates in achieving a CS certification. With the blended model, even teachers with no background knowledge in CS were successful. Within our pre-service CS program, students first complete a two-course pathway that prepares them in AP CSP content and pedagogy experiences, including observations in local AP CSP classrooms [3]. After completing the two courses, our students participate in the blended version of the WeTeach_CS Praxis preparation course to achieve certification. The in-person support provided by the blended model contributed significantly to certification success in this project. With a cut-score of 149 for the Praxis exam, all 11 of our pre-service students who completed the course received a passing score (including one student with a perfect score of 200, and another student with a 195); the average score for our pre-service students was 175. An additional 11 in-service teachers, with diverse backgrounds in CS content knowledge, also participated in the blended Praxis preparation course, with an average score of 166. Incorporating an asynchronous online course that allows teachers with a wide range of prior experience in CS to learn at their own pace with in-person coursework and support appears to be a viable model for assisting non-CS major teacher candidates in achieving a CS certification. With the blended model, even teachers with no background knowledge in CS were successful.

The Exploring Computer Science (ECS) curriculum provides foundational knowledge of Computer Science (CS) to high school students as a stand-alone course. ECS began in the Los Angeles Unified School District in the late 2000s where it gained eminence for broadening participation in computing (BPC), with Latinx students representing over 70% of enrollment. This experience report describes a partnership that consists of three Universities, dozens of school districts, the ECS team, and other stakeholders to bring the ECS curriculum in mainly rural school districts in Alabama that have a majority African-American student population. Sixty in-service teachers (one teacher per school) have received professional learning opportunities to gain knowledge and skills to teach ECS. Signs of early broader impacts are emerging: 78% of our ECS enrollment are underrepresented minority (URM) students with nearly half of the cohort consisting of female students. Students reported they were engaged in working collaboratively and sharing responsibilities with others. Furthermore, students who reported being more involved in the ECS course had deeper confidence in their ability to succeed in CS, reported greater overall outcomes, had more confidence in development of 21st century skills, found the course more relevant, were more motivated to persist in CS, and exhibited increased interest in CS careers. We provide a comprehensive description of the partnership's accomplishments and the evaluation findings on student CS experiences and on teacher self-efficacy in ECS preparation and instruction. Our findings contribute to the BPC literature, specifically for schools with predominantly African-American enrollment in rural communities.

Software Product Lines (SPLs) play an important role in the context of large-scale production of software families. Feature models (FMs) are essential in SPLs by representing all the commonalities and variabilities in a product line. Currently, several tools support automated analysis of FMs, such as checking the consistency of FMs and counting the valid configurations of a product line. Although these tools greatly reduce the complexity of FM analysis, FM design is often performed manually, thus being prone to bad design choices in the domain analysis phase. This paper reports on our work to improve FM qualities from the exploration of the relationship between FM structure and structural complexity. By performing two common operations (i.e., consistency checking and counting valid configurations on FMs with different sizes and structures), we collected the time that an automated tool needs to finish these operations. Then, we applied data mining approaches to explore the relationship between FM structure and structural complexity. In addition, we provide guidelines for designing FMs based on our observations.

The Advanced Placement Computer Science Principles (AP CSP) course was the culmination of an eight-year NSF/College Board pilot project that exceeded all expectations in terms of enrollment in its first two official years. Four NSF-sponsored projects and six other projects have endorsed AP CSP curricula and professional development (PD), a first for an AP course. In this paper, we report on an NSF-sponsored multi-year effort to infuse cooperative learning (CL) structures into AP CSP classrooms to improve class participation and student learning. As we report, CL structures have been beneficial for both new and experienced teachers and across the curricula of the endorsed providers. Since AP CSP was designed to engage all learners, the CL structures used in our PD workshops and the CL resources designed by participating teachers in our project have the potential to positively impact all AP CSP classrooms. Research was conducted on the extent to which use of CL structures impacted student efficacy and student achievement. Three cohorts of AP CSP teachers participated in PD that focused on AP CSP pedagogical content knowledge using CL structures. A cumulative 143 teachers attended one-week PD workshops spanning July 2015, 2016, and 2017. We studied the effect of CL structures on student learning using AP scores as an outcomes measure. Use of CL structures was a statistically significant and positive predictor of student AP scores for participating classes in cohorts 2 and 3. Additionally, the use of pair programming was a significant and positive predictor of AP scores.

This poster provides a description of an NSF-sponsored project entitled "ECS4Alabama" that addresses one of the nation's areas of highest priority in K-12 education: To offer all children opportunities for preparation in authentic Computer Science, with a specific focus on students from rural high-minority schools. ECS4Alabama addresses this need locally in Alabama by preparing teachers to offer a stand-alone, College preparatory Computer Science course - Exploring Computer Science (ECS) - in the participating high schools. Over the last two years, 52 in-service teachers have received training on ECS who in turn are teaching the course to nearly 1,500 students. Approximately 80% of the enrollment is minority and 48% of the students are young women. In many communities, ECS4Alabama is bringing access to challenging Computer Science curricula in school districts that often lack preparatory experiences that are typically only available to students in more affluent districts. Teachers Leaders are emerging and are spearheading Professional Development Communities to assist their peers with ECS implementation. In addition to sharing ECS4Alabama's implementation successes and challenges, the poster will also describe the project's rigorous evaluative and Social Science research components. Initial findings reveal that ECS professional development opportunities enhance teachers' self-efficacy and confidence in teaching CS through a problem-based, engaging curriculum that teachers view as relatable and relevant to students' daily lives. Students report that teachers make great efforts to facilitate their involvement in cognitively demanding work to solve real problems, encourage autonomy and stimulate student interest in CS.

Website visitors are performing increasingly complex computational work on the websites' behalf, such as validating forms, rendering animations, and producing data visualizations. In this article, we explore the possibility of increasing the work offloaded to web visitors' browsers. The idle computing cycles of web visitors can be turned into a large-scale distributed data processing engine, which we term gray computing. Past research has looked primarily at either volunteer computing with specialized clients or browser-based volunteer computing where the visitors keep their browsers open to a single web page for a long period of time. This article provides a comprehensive analysis of the architecture, performance, security, cost effectiveness, user experience, and other issues of gray computing distributed data processing engines with heterogeneous computing power, non-uniform page view times, and high computing pool volatility. Several real-world applications are examined and gray computing is shown to be cost effective for a number of complex tasks ranging from computer vision to bioinformatics to cryptology.

Much well-deserved attention in K-12 Computer Science (CS) education has focused recently on the successful launch of the College Board's new AP CS Principles course, which is breaking participation records and broadening CS participation. To further leverage the national investment in a successful high school CS program, however, it is important to create, sustain and study a continuous CS pipeline that begins early and spans all grade levels. This experience report articulates the characteristics of Code.org's K-5 CS Fundamentals (CSF) program and summarizes the experiences of adopting the CSF curriculum to support large-scale, university-driven K-5 Professional Development (PD) programs across two states in different geographical regions of the USA. An overview of Code.org's CSF curriculum and PD survey data is provided, followed by a summary of each state's experience. A set of lessons learned offers recommendations for those considering implementation of statewide PD programs in K-5 CS; future plans are discussed to investigate observations from this experience report within a formal research setting.

Abstract Text retrieval–based feature location techniques (FLTs) use information from the terms present in documents in classes and methods. However, relevant terms originating from certain locations (eg, method names) often comprise only a small part of the entire method lexicon. Feature location techniques should benefit from techniques that make greater use of this information. The primary objective of this study was to investigate how weighting terms from different locations in source code can improve a latent Dirichlet allocation (LDA)‐based FLT. We conducted an empirical study of 4 subject software systems and 372 features. For each subject system, we trained 1024 different LDA models with new weighting schemes applied to leading comments, method names, parameters, body comments, and local variables. We conducted both a quantitative and qualitative analysis to identify the effects of using the weighting schemes on the performance of the LDA‐based FLT. We evaluated weighting schemes based on mean reciprocal rank and spread of effectiveness measures. In addition, we conducted a factorial analysis to identify which locations have a main impact on the results of the FLT. We then examined the effects of adding information from class comments, class names, and fields to the top 10 configurations for each system. This results in an additional 640 different LDA models for each system. From our results, we identified a significant effect in the performance of an LDA‐based weighting configuration when applying our weighting schemes to the LDA‐based FLT. Furthermore, we found that adding information from each method's containing class can improve the effectiveness of an LDA‐based FLT. Finally, we identified a set of recommendations for identifying better weighting schemes for LDA.

2017 has been an exciting year for SoSyM, which has now passed its 16 th year of publication!We have continued to intensify our collaboration with the MODELS conference by presenting the annual SoSyM Awards at MODELS and strengthening the SoSyM "Journal-First" arrangement with MODELS.The first issue of this new year's volume summarizes the status of SoSyM in terms of recent statistics and milestone events over the past year.As an additional testament to the interest and growth in our field, recent full professorship positions have been offered in the area of software and systems modeling, which means the area has now advanced from a subdomain of software engineering, data modeling, formal methods, and related areas to its own sustainable research domain.Unfortunately, in 2017 we also lost one of our best friends who was one of the early members of our community.Bernhard Schätz passed away from cancer in July, 2017.As a memorial to Bernhard, this editorial is also accompanied with a scientific appreciation of his life.

No abstract available.

The College Board estimates that the new AP CS Principles (CSP) course will set a participation record for new course launches. With a large number of students across the USA enrolling in CSP at the high school level, CS departments at colleges and universities will need to begin considering their position for awarding AP credit. One possibility is the introduction of a new college-focused CSP course for non-majors that can serve as a mapping for AP credit. This paper summarizes the experiences of two faculty at different universities who were official CSP College Board Pilots for several years. An overview of each university's experience is provided in terms of student demographics, common evaluation measures, and individual course nuances, followed by a series of recommendations to faculty who are considering the creation of a CSP course within the curriculum of their own department.

This poster describes how this project has induced teacher preparation and broadened student participation in Computer Science Principles throughout Alabama from 2013-2016. We will describe our professional development (PD) model, gain for participating instructors, results of CS Principles course implementations, and student engagement and outcomes. A statewide and scalable "Teacher Leader" model of professional development was implemented throughout the project. In person training was coupled with on-line course content, geographically proximal teacher groups, and periodic teacher hangouts. Teachers in each cohort collaborated together on developing course content and pedagogy, fostered by peer leaders from earlier cohorts. Instructors encouraged and engaged their students; student agreed that the learning environments supported diversity. Students gained significantly in core computer science content (i.e., abstraction and algorithms) as well as computational thinking practices. Female students showed robust gains on a number of indicators (including higher course grades than males); under-represented minority students showed positive gains in content knowledge. The majority of students said they were likely or possibly likely to pursue computer science in college, and that taking CS Principles impacted their decisions.

Various disciplines use models for different purposes. While engineering models, including software engineering models, are often developed to guide the construction of a nonexistent system, scientific models, in contrast, are created to better understand a natural phenomenon (i.e., an already existing system). An engineering model may incorporate scientific models to build a system. Both engineering and scientific models have been used to support sustainability, but largely in a loosely-coupled fashion, independently developed and maintained from each other. Due to the inherent complex nature of sustainability that must balance trade-offs between social, environmental, and economic concerns, modeling challenges abound for both the scientific and engineering disciplines. This paper offers a vision that synergistically combines engineering and scientific models to enable broader engagement of society for addressing sustainability concerns, informed decision-making based on more-accessible scientific models and data, and automated feedback to the engineering models to support dynamic adaptation of sustainability systems. To support this vision, we identify a number of research challenges to be addressed with particular emphasis on the socio-technical benefits of modeling.

Many new curricula and tools have been developed recently to promote the exciting opportunities available in computer science. However, curriculum and supporting tools alone do not drive engagement -- the most interesting and innovative curriculum can still be taught in a disengaged manner, leading to lost opportunities for broadening the appeal and interest in computing across a diverse student population. The learning science literature on Cooperative Learning (CL) has been shown to increase class participation and student learning, while also promoting diversity in a manner that supports the differentiated instruction needed to engage students who have mixed abilities. This workshop will demonstrate how the best practices of CL can be applied in early CS courses (e.g., AP CS Principles AP CS A, or CS1). Workshop participants will be introduced to the CL structures that have been used in many different disciplines across multiple age/grade levels. These structures will be used to demonstrate specific applications toward computer science concepts. The workshop itself will be taught in a cooperative learning style so that participants can understand the dynamics and structure of a CL classroom. This workshop is intended for two types of educators: 1) K-12 teachers currently teaching AP CS A, CS Principles (CSP), or other introductory programming courses and 2) university faculty currently teaching CS 1 or other introductory computer science courses.

CS Principles is a new AP course being developed by the College Board and introduced into high schools across the nation. To aid and encourage the adoption of the new CSP course, we have developed a Massively-Open Online Course (MOOC) over the past two years that serves as a professional development (PD) offering for CS Principles. Additionally, we have provided a parallel face-to-face workshop for a smaller group of MOOC participants. In this paper, we discuss our experiences conducting PD using a MOOC. We investigated the impact of the face-to-face event and online community on participants' completion and performance in the course. Our analysis suggests that participants who have even just a few days of face-to-face engagement tend to be more successful in completing a multi-week MOOC.

Block languages (e.g., Scratch, Snap!, Alice, App Inventor, Blockly) offer a gentle introduction to programming and have been adopted widely in both K-12 and CS0 courses. However, block languages often are dependent on the mouse/keyboard for input and typically are visual in their output and representation. Because of these dependencies, students with a disability (e.g., mobility limitations or vision impairment) generally are unable to use block languages, thereby reducing the opportunities for broader participation in computational learning activities. Given the increasing need to broaden the participation of computing to those with diverse skills and backgrounds, it is important that the tools used to initiate the earliest entre into computing do not erect immediate roadblocks that impede initial interest and opportunity. There are many variations of user interfaces and assistive technologies that benefit those who may have difficulties utilizing traditional Graphical User Interfaces (GUIs), but these tools often cannot be used universally across block languages. As more block languages are being developed and integrated into K12 and University curriculum, it is imperative that accessible solutions are discussed and implemented. These discussions require participation from the block language developer community, accessible computing community, and those educators who encounter accessibility needs among the students in their classrooms. The goal of this lightning talk is to call attention to the need for more accessible block-based programming environments and to spark conversation surrounding possible standard accessibility APIs that could possibly be supported by block language environment tool developers.

Models are an important tool in conquering the increasing complexity of modern software systems. Key industries are strategically directing their development environments towards more extensive use of modeling techniques. MiSE 2015 aimed to understand, through critical analysis, the current and future uses of models in the engineering of software-intensive systems. The MiSE workshop series has proven to be an effective forum for discussing modeling techniques from both the MDE and software engineering perspectives. An important goal of this workshop is to foster exchange between these two communities. In 2015 the focus was on considering the current state of tool support and the challenges that need to be addressed to improve the maturity of tools. There was also analysis of successful applications of modeling techniques in specific application domains, with attempts to determine how the participants' experiences can be carried over to other domains.

Websites routinely distribute small amounts of work to visitors' browsers in order to validate forms, render animations, and perform other computations. This paper examines the feasibility, cost effectiveness, and approaches for increasing the workloads offloaded to web visitors' browsers in order to turn them into a large-scale distributed data processing engine, which we term gray computing. Past research has looked primarily at either non-browser based volunteer computing or browser-based volunteer computing where the visitors keep their browsers open to a single web page for a long period of time. This paper provides a deep analysis of the architectural, cost effectiveness, user experience, performance, security, and other issues of gray computing distributed data processing engines with high heterogeneity, non-uniform page view times, and high computing pool volatility.

No abstract available.

No abstract available.

The recent successes of Computer Science Education Week and code.org's Hour of Code have meant that more K-12 students than ever are being given an authentic, engaging and eye-opening exposure to the wonders of computer science. There are resources aplenty to help high school and college faculty with outreach. These range from easy-to-learn, open-ended programming environments (Scratch, Alice, Snap!), to online coding challenges (code.org, Lite-bot), to non-computer activities with live performances (CS Unplugged, cs4fn), to having the entire outreach experience delivered "in a box", thanks to NCWIT.

This poster describes our experience with the convening of a statewide committee of Mathematics and Computer Science teachers and content specialists to compare the content of the AP Computer Science A Course (AP CS A) and the Computer Science Principles (CSP) course with the Alabama Course of Study-Mathematics. The purpose of the comparison was to identify overlaps in content and to make recommendations to the State Department of Education and the State Board of Education regarding the option of awarding mathematics credit for completion of the Computer Science courses. This crosswalk activity led to the December 2013 decision by the Alabama State Department of Education (ALSDE) to count both CS Principles and CS A as courses satisfying the four-course requirement for high school graduation in Alabama. The poster will describe the crosswalk activity, the results, and the specific strategic approach to involve the ALSDE as collaborators in the activity.

This paper summarizes our mid-project results in developing and evaluating a CS Principles (CSP) professional development (PD) model for training several cohorts of teachers across an entire state geography. CS4Alabama is an NSF-funded project that has adopted the successful practices of a national AP training program developed by the National Math and Science Initiative (NMSI) in pursuit of scalable deployment and sustainable persistence of new CSP courses across Alabama. We have created a CSP curriculum and PD program based on year-long in-person training and distance learning collaboration, which also was offered as a national MOOC as part of Google CS4HS. A statewide Teacher Leader (TL) model is used, where those who have previously taught rigorous CS courses serve as mentors in training new peer cohorts as they establish CSP courses in their schools. Teachers in these cohorts collaborate together on content and pedagogical learning experiences, fostered by the TLs. This paper reports on assessment results that are uncovering the facets of our model that are most suitable for building a sustainable network of CSP teachers. The paper summarizes our PD model, offers various lessons learned, and details the findings of the project's external evaluation team.

Many new curricula and tools have been developed recently to promote the exciting opportunities available in computer science. However, curriculum and supporting tools alone do not drive engagement -- the most interesting and innovative curriculum can still be taught in a disengaged manner, leading to lost opportunities for broadening the appeal and interest in computing across a diverse student population. The learning science literature on Cooperative Learning (CL) has been shown to increase class participation and student learning, while also promoting diversity in a manner that supports the differentiated instruction needed to engage students who have mixed abilities. This workshop will demonstrate how the best practices of CL can be applied in early CS courses (e.g., CS Principles, AP CS A, or CS1). Workshop participants will first be introduced to the CL structures that have been used in many different disciplines across multiple age/grade levels. These structures will then be used to demonstrate specific application toward computer science concepts. The workshop itself will be taught in a cooperative learning style so that participants can understand the dynamics and structure of a CL classroom. This workshop is for two categories of educations: 1) K-12 teachers who have experience with either AP CS A or CS Principles, or 2) university faculty who teach CS1 or other early courses.

Over the past decade, an increased interest has emerged in block-based languages that have been used to support initial exposure of programming concepts to new learners (children or adult). Such languages can shield initial-learners from some of the frustrations of learning the syntax of a programming language, and allow them to focus on the core computational idea being taught. Blockly is a type of visual block language development kit that allows the rapid construction of new block-based visual programming languages to address a specific pedagogical or content focus. This demo provides a brief tutorial on the steps used to create a new Blockly environment, along with two case studies demonstrating the power of Blockly. The two environments introduced have two different contexts: the manipulation of images via operations on pixels (Pixly), and programmatic control of a Sphero robot (Spherly). Pixly and Spherly serve as a context for introducing how new Blockly languages are created, as well as showcasing the opportunity to use these languages as new educational environments in the context of media computation and robotics. More information can be found at http://outreach.cs.ua.edu/pixly/ and http://outreach.cs.ua.edu/spherly/. This work is supported by an NSF CE21 project and a Google CS4HS award.

Introducing programming concepts to children early in their education can be beneficial because the type of problem solving that encompasses computational thinking is becoming increasingly relevant in our daily lives. A relatively new breed of programming environments has emerged to address this need. Visual programming languages (VPLs) allow programming logic to be represented with diagrams that illustrate its execution flow. Popular VPLs (e.g., Scratch, Snap, Alice, App Inventor) exist as full-featured, stand-alone programming environments with diagrammatic representations of the program instructions. This representation removes the syntactical barrier to entry that may exist with textual languages.

Omniscient debugging is a promising technique that relies on execution traces to enable free traversal of the states reached by a system during an execution. While some General-Purpose Languages (GPLs) already have support for omniscient debugging, developing such a complex tool for any executable Domain-Specific Modeling Language (xDSML) remains a challenging and error prone task. A solution to this problem is to define a generic omniscient debugger for all xDSMLs. However, generically supporting any xDSML both compromises the efficiency and the usability of such an approach. Our contribution relies on a partly generic omniscient debugger supported by generated domain-specific trace management facilities. Being domain-specific, these facilities are tuned to the considered xDSML for better efficiency. Usability is strengthened by providing multidimensional omniscient debugging. Results show that our approach is on average 3.0 times more efficient in memory and 5.03 more efficient in time when compared to a generic solution that copies the model at each step.

No abstract available.

Our grand challenge is to scale high-quality computer science curriculum and instruction to reach all high school students. CS10K -- an NSF and ACM-sponsored project -- is working to do just that by supporting curriculum development, computer education research and professional development through the Computing Education for the 21st Century (CE21) program at NSF. Professional Development (PD) is a key piece of the project, as we need to train 10,000 teachers to teach rigorous computing courses in 10,000 high schools by 2016 -- the school year that a new Advanced Placement Course will be rolled out. This panel will provide an overview of the PD landscape and then each panelist will discuss the unique aspects of their PD project for high school teachers.

This poster describes our first-year experience in developing and evaluating a CS Principles professional development model for training a cohort of teachers across an entire state geography. The scalable deployment and sustainable persistence of the new CS Principles course adopts the successful practices of a national AP training program developed by the National Math and Science Initiative (NMSI). It applies those practices in a professional development program based on year-long in-person training and distance learning collaboration. A statewide "Teacher Leader" model is being explored where those already teaching more rigorous CS courses will assist in training new peer cohorts as they establish CS Principles in their schools. Teachers in these cohorts collaborate together on content and pedagogical learning experiences, fostered by peer leaders. The assessment is uncovering the facets of our model that are most suitable for building a sustainable network of CS Principles teachers. This poster is focused on a description of our first-year experiences and extensive evaluation results. The poster will describe the curriculum that is being developed by our teachers, a set of lessons learned from our PD experiences, and the details of our evaluation. The Teacher Leaders will be available near the poster to discuss their experience with anyone who has an interest in our professional development model for CS Principles.

During the Summer of 2013, we participated in a United Cerebral Palsy supported summer camp for children with disabilities. While our initial motivation for attending the camp was to conduct a user study of a Vocal User Interface, we worked with the camp attendees outside of testing and beyond computer activities, and during these activities, we were able to ask the attendees about their computer experience and interest. The attendees' experience and interest was noted along with the results of the study. The study demonstrated that voice was a useful modality for this audience; however, we were more surprised to learn that the majority of the attendees were not enthusiastic about using the computer and preferred more social activities. Three different types of computer science education activities were offered during the six week camp. The first activity was a group activity in which roughly ten students participated. The next activity was completed with smaller groups consisting of 2-3 attendees in which five students participated throughout the camp. The final activity was a one-on-one activity, and only three students chose to participate in the one-on-one activity. This poster presents the details of these activities, results of the user study, and thoughts as to why few attendees chose to participate in the smaller group activities based on observations during the summer camp.

Models are an important tool in conquering the increasing complexity of modern software systems. Key industries are strategically directing their development environments towards more extensive use of modeling techniques. This workshop sought to understand, through critical analysis, the current and future uses of models in the engineering of software-intensive systems. The MISE-workshop series has proven to be an effective forum for discussing modeling techniques from the MDD and the software engineering perspectives. An important goal of this workshop was to foster exchange between these two communities. The 2013 Modeling in Software Engineering (MiSE) workshop was held at ICSE 2013 in San Francisco, California, during May 18–19, 2013. The focus this year was analysis of successful applications of modeling techniques in specific application domains to determine how experiences can be carried over to other domains. Details are available at: https://sselab.de/lab2/public/wiki/MiSE/index.php.

Mobile-enabled systems make use of mobile devices, RFID tags, sensor nodes, and other computing-enabled mobile devices to gather contextual data from users and the surrounding changing environment. Such systems produce computational data that can be stored and used in the field, shared between mobile and resident devices, and potentially uploaded to local servers or the cloud — a distributed, heterogeneous, context-aware, data production and consumption paradigm. Mobile-enabled systems have characteristics that make them different from traditional systems, such as limited resources, increased vulnerability, performance and reliability variability, and a finite energy source. There is significantly higher unpredictability in the execution environment of mobile apps. This workshop brings together experts from the software engineering and mobile computing communities — with notable participation from researchers and practitioners in the field of distributed systems, enterprise systems, cloud systems, ubiquitous computing, wireless sensor networks, and pervasive computing — to share results and open issues in the area of software engineering of mobile-enabled systems.

In this paper we analyze the CS Principles project, a proposed Advanced Placement course, by focusing on the second pilot that took place in 2011-2012. In a previous publication the first pilot of the course was explained, but not in a context related to relevant educational research and philosophy. In this paper we analyze the content and the pedagogical approaches used in the second pilot of the project. We include information about the third pilot being conducted in 2012-2013 and the portfolio exam that is part of that pilot. Both the second and third pilots provide evidence that the CS Principles course is succeeding in changing how computer science is taught and to whom it is taught.

Educators are often seeking new ways to motivate or inspire students to learn. Our past efforts in K-12 outreach included robotics and media computation as the contexts for teaching Computer Science (CS). With the deep interest in mobile technologies among teenagers, our recent outreach has focused on using smartphones as a new context. This paper is an experience report describing our approach and observations from teaching a summer camp for high school students using App Inventor (AI). The paper describes two separate methods (one using a visual block language, and another using Java) that were taught to high school students as a way to create Android applications. We observed that initiating the instruction with the block language, and then showing the direct mapping to an equivalent Java version, assisted students in understanding app development in Java. Our evaluation of the camp includes observations of student work and artifact assessment of student projects. Although the assessment suggests the camp was successful in several areas, we present numerous lessons learned based on our own reflection on the camp content and instruction.

ABSTRACT Domain‐Specific Modeling Languages (DSMLs) are playing an increasingly significant role in software development. By raising the level of abstraction using notations that are representative of a specific domain, DSMLs allow the core essence of a problem to be separated from irrelevant accidental complexities, which are typically found at the implementation level in source code. In addition to modeling the functional aspects of a system, a number of nonfunctional properties (e.g., quality of service constraints and timing requirements) also need to be integrated into models in order to reach a complete specification of a system. This is particularly true for domains that have distributed real time and embedded needs. Given a base model with functional components, maintaining the nonfunctional properties that crosscut the base model has become an essential modeling task when using DSMLs. The task of maintaining nonfunctional properties in DSMLs is traditionally supported by manual model editing or by using model transformation languages. However, these approaches are challenging to use for those unfamiliar with the specific details of a modeling transformation language and the underlying metamodel of the domain, which presents a7 steep learning curve for many users. This paper presents a demonstration‐based approach to automate the maintenance of nonfunctional properties in DSMLs. Instead of writing model transformation rules explicitly, users demonstrate how to apply the nonfunctional properties by directly editing the concrete model instances and simulating a single case of the maintenance process. By recording a user's operations, an inference engine analyzes the user's intention and generates generic model transformation patterns automatically, which can be refined by users and then reused to automate the same evolution and maintenance task in other models. Using this approach, users are able to automate the maintenance tasks without learning a complex model transformation language. In addition, because the demonstration is performed on model instances, users are isolated from the underlying abstract metamodel definitions. Our demonstration‐based approach has been applied to several scenarios, such as auto scaling and model layout. The specific contribution in this paper is the application of the demonstration‐based approach to capture crosscutting concerns representative of aspects at the modeling level. Several examples are presented across multiple modeling languages to demonstrate the benefits of our approach. Copyright © 2013 John Wiley & Sons, Ltd.

Domain-specific modeling languages (DSMLs) are designed to model particular domains of interest using graphical, textual, or mixed syntax. Although most metamodeling tools offer an environment that automates several language development tasks, there is still a lack of support for aiding the domain expert to capture the requirements of a graphical DSML. We introduce the Syntax Map as an approach to address the challenges of graphical DSML requirements specification. It is designed to aid domain experts in describing a first-class graphical DSML requirement using a set of graphical notations. In addition, the Syntax Map can be used to generate a metamodel by means of model transformations. This short paper motivates the need for the Syntax Map, provides several brief examples, and discusses lessons learned in our investigation of this approach.

Domain-Specific Modeling Languages (DSMLs) have received recent interest due to their conciseness and rich expressiveness for modeling a specific domain. However, DSML adoption has several challenges because development of a new DSML requires both domain knowledge and language development expertise (e.g., defining abstract/concrete syntax and specifying semantics). Abstract syntax is generally defined in the form of a metamodel, with semantics associated to the metamodel. Thus, designing a metamodel is a core DSML development activity. Furthermore, DSMLs are often developed incrementally by iterating across complex language development tasks. An iterative and incremental approach is often preferred because the approach encourages end-user involvement to assist with verifying the DSML correctness and feedback on new requirements. However, if there is no tool support, iterative and incremental DSML development can be mundane and error-prone work. To resolve issues related to DSML development, we introduce a new approach to create DSMLs from a set of domain model examples provided by an end-user. The approach focuses on (1) the identification of concrete syntax, (2) inducing abstract syntax in the form of a metamodel, and (3) inferring static semantics from a set of domain model examples. In order to generate a DSML from user-supplied examples, our approach uses graph theory and metamodel design patterns.

Designing a high quality model transformation is critical, because it is the pivotal mechanism in many mission applications for evolving the intellectual design described by models. This paper proposes solution ideas to assist modelers in developing high quality transformation models. We propose to initiate a design pattern movement in the context of model transformation. The resulting catalog of patterns shall satisfy quality attributes identified beforehand. Verification and validation of these patterns allow us to assess whether the cataloged design patterns are sound and complete with respect to the quality criteria. This will lead to techniques and tools that can detect bad designs and propose alternatives based on well-thought design patterns during the development or maintenance of model transformation.

Domain-agnostic signature discovery entails study across multiple scientific disciplines. The cross-disciplinary nature and breadth of this work requires that existing executable applications be integrated with new capabilities into workflows, representing a wide range of user tasks. An algorithm may be written in multiple programming languages for various hardware platforms, and so workflow composition requires integrating executables from any number of remote hosts. This raises an engineering issue on how to generate web service wrappers for these heterogeneous executables and to compose them into a scientific workflow environment (e.g., Taverna). In this position paper, we summarize our work on two simple Domain-Specific Languages (DSLs) that automate these processes. Our Service Description Language (SDL) describes key elements of a signature discovery service and automatically generates its implementation code. The Workflow Description Language (WDL) describes the pipeline of services and generates deployable artifacts for the Taverna workflow management system. We demonstrate our approach with a real-world workflow composed of services wrapping remote executables.

App Inventor for Android is a visual blocks language for building mobile apps. Like Scratch, the language's drag-and-drop blocks interface significantly lowers the barrier to entry. Beginners can immediately build apps that interface with mobile technology (e.g., GPS, Text-to-speech, SMS Texting) and build apps that have a real-world impact. App Inventor has great potential for increasing interest in programming and attracting women and other underrepresented groups to computer science. Students learn by tinkering with their most beloved devices, phones and tablets, and even novices can create apps in an exciting and intuitive environment. App Inventor is relevant to teachers from middle school through the university level who are interested in a highly motivating method of teaching programming. In this BoF, we will discuss the language, its future in K-12 and university education, and its new home at the MIT Center for Mobile Learning.

No abstract available.

Mobile phone programming can provide teens an authentic and engaging hook into computer science. With App Inventor, developed by Google and moved to MIT, programming Android apps is as easy as clicking blocks together. App Inventor has been used successfully in after school programs, roadshows, summer camps, teacher workshops, and computer science classrooms from middle school through college. Participants will get an overview of App Inventor including project ideas and sample student code, hear outreach planning suggestions, write programs, develop outreach plans, and see how the Java Bridge helps transition from App Inventor to Java. Please bring a laptop with App Inventor. Even the most time-stretched professor or teacher can encourage students in computer science with App Inventor.

Over the last five years, CSTA has built a solid outreach and teacher support network through the work of its chapters and Leadership Cohort. This network has also become a major source of active partnerships between K-12 teachers, their schools, and colleagues from colleges, universities, and industry. The goal of this BOF is to provide concrete examples and suggestions for SIGCSE members interested in building these kinds of partnerships.

Smartphone sales are expected to outpace desktop/laptop computer sales in 2011. It is critical for software engineers to understand the key issues of building applications for this new platform. The mobile sensing and networking capabilities of smartphones create a unique platform for building cyberphysical and other applications that sense and respond to the environment. Moreover, social networking capabilities of these platforms offer new paradigms for dissemination of knowledge, harvesting of user relationship information, and following current events. This workshop will foster new ideas, approaches, and artifacts that can be used to support the introduction of smartphones into traditional software engineering courses (e.g., a survey course, or senior capstone design course, among others).

Model evolution is an essential activity in software system modeling, which is traditionally supported by manual editing or writing model transformation rules. However, the current state of practice for model evolution presents challenges to those who are unfamiliar with model transformation languages or metamodel definitions. This demonstration presents a demonstration-based approach that assists end-users through automation of model evolution tasks (e.g., refactoring, model scaling, and aspect weaving).

Software is an important part of industrial process control systems. However, the state-of-the-practice for developing industrial process control software still has several key challenges that need to be addressed (e.g., migration to platforms of different vendors, lack of automation). This paper introduces a model-driven engineering approach to the development of industrial process control software, which is based on the ProcGraph domain-specific modeling language. The paper discusses and offers solutions to several of the development challenges that have not been addressed by existing techniques in the process controls domain. The contributions of the paper are a model-driven engineering approach for the industrial process control domain and a supporting tool infrastructure. The approach is demonstrated by a case study focused on the development of a control system for a TiO2(titanium dioxide) pigment production subprocess.

Graphical Processing Unit (GPU) programming languages are used extensively for general-purpose computations. However, GPU programming languages are at a level of abstraction suitable only for use by expert parallel programmers. This paper presents a new approach through which `C' or Java programmers can access these languages without having to focus on the technical or language-specific details. A prototype of the approach, named CUDACL, is introduced through which a programmer can specify one or more parallel blocks in a file and execute in a GPU. CUDACL also helps the programmer to make CUDA or OpenCL kernel calls inside an existing program. Two scenarios have been successfully implemented to assess the usability and potential of the tool. The tool was created based on a detailed analysis of the CUDA and OpenCL programs. Our evaluation of CUDACL compared to other similar approaches shows the efficiency and effectiveness of CUDACL.

Model transformation is a core technology in Domain-Specific Modeling (DSM). While a number of model transformation languages and tools have been developed to support model transformation activities, the layout of visual models in the transformation process is not often considered. In many cases, after a transformation is performed the layout of the resulting model must be manually rearranged, which can be time consuming. The automatic layout arrangement features provided by some modeling tools usually do not take a user's preferences or the semantics of the model into consideration, and therefore could potentially alter the desired layout in an undesired manner. This paper describes a new approach to enable users to specify the model layout in a model transformation. We applied the Model Transformation By Demonstration (MTBD) approach and extended it to let users specify the layout information using the concept of "What You See Is What You Get" (WYSIWYG), so that the complex layout specification can be simplified.

Although there have been many benefits of Domain-Specific Languages (DSLs) reported from both academia and industry, implementation of DSLs continue to face challenges with respect to frequent evolution of both syntax and semantics. Techniques for implementing DSLs also lack interoperable capabilities among base languages and limited tool support. Such challenges result in increasing DSL development cost and constrain DSL adoption opportunities. This paper introduces a Service-Oriented Architecture (SOA) approach to address such problems. The approach utilizes WSDL to perform lexical and syntax analysis. Web services are used to define the semantics of a DSL, and WS-BPEL is then used to specify a DSL program. We present two case studies representing different DSL categories to show the feasibility of SOA-based DSL implementation. The case studies demonstrate the potential for easing the burden of DSL evolution and offering interoperability and tool support. Improved modularization and removal of tokenization/parsing are two additional advantages. Discussion and comparison among interpreter-based, model-driven and SOA-based DSL implementations are provided, which may raise more research interests in this area.

In model-driven engineering, metamodels may get lost over time resulting in the inability to load and view existing model instances. MARS is a system that recovers metamodels from model instances using grammar inference. This paper discusses advances in MARS that improve accuracy and scalability.

Abstract In model‐driven engineering, it is often desirable to evaluate different design alternatives as they relate to scalability issues of the modeled system. A typical approach to address scalability is model replication, which starts by creating base models that capture the key entities as model elements and their relationships as model connections. A collection of base models can be adorned with necessary information to characterize a specific scalability concern as it relates to how the base modeling elements are replicated and connected together. In current modeling practice, such a model replication is usually accomplished by scaling the base model manually. This is a time‐consuming process that represents a source of error, especially when there are deep interactions between model components. As an alternative to the manual process, this paper presents the idea of automated model replication through a model transformation process that expands the number of elements from the base model and makes the correct connections among the generated modeling elements. The paper motivates the need for model replication through case studies taken from models supporting different domains. Copyright © 2008 John Wiley & Sons, Ltd.

Abstract Domain‐specific languages (DSLs) assist a software developer (or end‐user) in writing a program using idioms that are similar to the abstractions found in a specific problem domain. Tool support for DSLs is lacking when compared with the capabilities provided for standard general‐purpose languages (GPLs), such as Java and C++. For example, support for debugging a program written in a DSL is often non‐existent. The lack of a debugger at the proper abstraction level limits an end‐user's ability to discover and locate faults in a DSL program. This paper describes a grammar‐driven technique to build a debugging tool generation framework from existing DSL grammars. The DSL grammars are used to generate the hooks needed to interface with a supporting infrastructure constructed for an integrated development environment that assists in debugging a program written in a DSL. The contribution represents a coordinated approach to bring essential software tools (e.g. debuggers) to different types of DSLs (e.g. imperative, declarative, and hybrid). This approach hides from the end‐users the accidental complexities associated with expanding the focus of a language environment to include debuggers. The research described in this paper addresses a long‐term goal of empowering end‐users with development tools for particular DSL problem domains at the proper level of abstraction without depending on a specific GPL. Copyright © 2007 John Wiley & Sons, Ltd.

A key enabler of the recently popularized, assembly-centric development approach for distributed real-time software systems is QoS-enabled middleware, which provides reusable building blocks in the form of design patterns that codify solutions to commonly recurring problems. These patterns can be customized by choosing an appropriate set of configuration parameters. The configuration options of the patterns exert a strong influence on system performance, which is of paramount importance in many distributed software systems. Despite this considerable influence, currently there is a lack of significant research to analyze performance of middleware at design time, where performance issues can be resolved at a much earlier stage of the application life cycle and with substantially less costs. The present project seeks to develop a performance analysis methodology for design-time performance analysis for distributed software systems implemented using middleware patterns and their compositions. The methodology is illustrated on a producer/consumer system implemented using the active object (AO) pattern in middleware. Finally, broader impacts of the methodology for middleware specialization are also described.

It has been observed by many practitioners that software applications frequently contain redundant code fragments. This redundancy is often caused by the common programming practice of replicating (or cloning) existing code and then customizing code fragments to handle new demands within an application. An IT organization consequently spends significant amounts of its budget maintaining such code (e.g., a bug in one code fragment is also a bug in all of its replicated clones). To address the challenges of clone detection and maintenance, this demo will introduce a new open source tool that can be used to visualize the results of CloneDR™, which is a commercial clone detection tool (a free version of the tool is available for Java). Several open source projects will be used as case studies to demonstrate the usage of the visualization tool

Model differentiation techniques, which provide the capability to identify mappings and differences between models, are essential to many model development and management practices. There has been initial research toward model differentiation applied to Unified Modeling Language (UML) diagrams, but differentiation of domain-specific models has not been explored deeply in the modeling community. Traditional modeling practice using the UML relies on a single fixed general-purpose language (i.e., all UML diagrams conform to a single metamodel). In contrast, Domain-Specific Modeling (DSM) is an emerging model-driven paradigm in which multiple metamodels are used to define various modeling languages that represent the key concepts and abstractions for particular domains. Therefore, domain-specific models may conform to various metamodels, which requires model differentiation algorithms be metamodel-independent and able to apply to multiple domain-specific modeling languages. This paper presents metamodel-independent algorithms and associated tools for detecting mappings and differences between domain-specific models, with facilities for graphical visualization of the detected differences.

Concurrency can be implemented in a Web server using synchronous and asynchronous mechanisms offered by the underlying operating system. Compared to the synchronous mechanisms, the asynchronous mechanisms are attractive because they provide the benefit of concurrency while alleviating much of the overhead and complexity of multithreading. The proactor pattern in middleware, which effectively encapsulates the asynchronous mechanisms supported by the operating system, can be used to implement a high performance Web server. In this paper, we present a queuing model of an asynchronous Web server implemented using the proactor pattern. We then describe a decomposition strategy to enable the application of the model in practical scenarios. We demonstrate the use of the model to guide configuration and provisioning decisions with several examples

The growing reliance on services provided by software applications places a high premium on the reliable and efficient operation of these applications. A number of these applications follow the event-driven software architecture style since this style fosters evolvability by separating event handling from event demultiplexing and dispatching functionality. The event demultiplexing capability, which appears repeatedly across a class of event-driven applications, can be codified into a reusable pattern, such as the reactor pattern. In order to enable performance analysis of event-driven applications at design time, a model is needed that represents the event demultiplexing and handling functionality that lies at the heart of these applications. In this paper, we present a model of the reactor pattern based on the well-established stochastic reward net (SRN) modeling paradigm. We discuss how the model can be used to obtain several performance measures such as the throughput, loss probability and upper and lower bounds on the response time. We illustrate how the model can be used to obtain the performance metrics of a virtual private network (VPN) service provided by a virtual router (VR). We validate the estimates of the performance measures obtained from the SRN model using simulation

The ever increasing societal demand for the timely availability of newer and feature-rich but highly dependable network-centric applications imposes the need for these applications to be constructed by the composition, assembly and deployment of off-the-shelf infrastructure and domain-specific services building blocks. Service oriented architecture (SOA) is an emerging paradigm to build applications in this manner by defining a choreography of loosely coupled building blocks. However, current research in SOA does not yet address the per for mobility (i.e., performance and dependability) challenges of these modern applications. Our research is developing novel mechanisms to address these challenges. We initially focus on the composition and configuration of the infrastructure hosting the individual services. We illustrate the use of domain-specific modeling languages and model weavers to model infrastructure composition using middleware building blocks, and to enhance these models with the desired performability attributes. We also demonstrate the use of generative tools that synthesize metadata from these models for performability validation using analytical, simulation and empirical benchmarking tools.

Abstract Advances in computer technologies have enabled scientists to explore research issues in their respective domains at scales greater and finer than ever before. The availability of efficient data collection and analysis tools presents researchers with vast opportunities to process heterogeneous data within a distributed environment. To support the opportunities enabled by massive computation, a suitable scientific workflow system is needed to help the users to manage data and programs, and to design reusable procedures of scientific experimental tasks. In this paper, the design and prototype implementation of a scientific workflow infrastructure, called Grid‐Flow, is presented. Grid‐Flow assists researchers in specifying scientific experiments using a Petri‐net‐based interface. The Grid‐Flow infrastructure is designed as a Service Oriented Architecture with multi‐layer component models. The contributions of Grid‐Flow are as follows: (1) a new, lightweight, programmable Grid workflow language, Grid‐Flow Description Language, is provided to describe the workflow process in a Grid environment; (2) a Petri‐net‐based user interface, based on the Generic Modeling Environment, is demonstrated to help the user design the workflow process with a Petri‐net model; and (3) a program integration component of the Grid‐Flow system is presented to integrate all possible programs into the system. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract The Grid has proven to be a successful paradigm for distributed computing. However, constructing applications that exploit all the benefits that the Grid offers is still not optimal for both inexperienced and experienced users. Recent approaches to solving this problem employ a high‐level abstract layer to ease the construction of applications for different Grid environments. These approaches help facilitate construction of Grid applications, but they are still tied to specific programming languages or platforms. A new approach is presented in this paper that uses concepts of domain‐specific modeling (DSM) to build a high‐level abstract layer. With this DSM‐based abstract layer, the users are able to create Grid applications without knowledge of specific programming languages or being bound to specific Grid platforms. An additional benefit of DSM provides the capability to generate software artifacts for various Grid environments. This paper presents the Grid Automation and Generative Environment (GAUGE). The goal of GAUGE is to automate the generation of Grid applications to allow inexperienced users to exploit the Grid fully. At the same time, GAUGE provides an open framework in which experienced users can build upon and extend to tailor their applications to particular Grid environments or specific platforms. GAUGE employs domain‐specific modeling techniques to accomplish this challenging task. Copyright © 2005 John Wiley & Sons, Ltd.

Domain-specific models increase the level of abstraction used to develop large-scale component-based systems. Model-driven development (MDD) approaches (e.g., Model-Integrated Computing and Model-Driven Architecture) emphasize the use of models at all stages of system development. Decomposing problems using MDD approaches may result in a separation of the artifacts in a way that impedes comprehension. For example, a single concern (such as deployment of a distributed system) may crosscut different orthogonal activities (such as component specification, interaction, packaging and planning). To keep track of all entities associated with a component, and to ensure that the constraints for the system as a whole are not violated, a purely model-driven approach imposes extra effort, thereby negating some of the benefits of MDD. This paper provides three contributions to the study of applying aspect-oriented techniques to address the crosscutting challenges of model-driven component-based distributed systems development. First, we identify the sources of crosscutting concerns that typically arise in model-driven development of component-based systems. Second, we describe how aspect-oriented model weaving helps modularize these crosscutting concerns using model transformations. Third, we describe how we have applied model weaving using a tool called the Constraint-Specification Aspect Weaver (C-SAW) in the context of the Platform-Independent Component Modeling Language (PICML), which is a domain-specific modeling language for developing component-based systems. A case study of a joint-emergency response system is presented to express the challenges in modeling a typical distributed system. Our experience shows that model weaving is an effective and scalable technique for dealing with crosscutting aspects of component-based systems development.

Society is becoming increasingly reliant on the services provided by distributed, performance sensitive software systems. These systems demand multiple simultaneous quality of service (QoS) properties. A key enabler in recent successes in the development of such systems has been middleware, which comprises reusable building blocks. Typically, a large number of configuration options are available for each building block when composing a system end-to-end. The choice of the building blocks and their configuration options have an impact on the performance of the services provided by the systems. Currently, the effect of these choices can be determined only very late in the lifecycle, which can be detrimental to system development costs and schedules. In order to enable the right design choices, a systematic methodology to analyze the performance of these systems at design time is necessary. Such a methodology may consist of models to analyze the performance of individual building blocks comprising the middleware and the composition of these building blocks. As a first step towards building this methodology, this paper introduces a model of the reactor pattern, which provides important synchronous demultiplexing and dispatching capabilities to network services and applications. The model is based on the stochastic reward net (SRN) modeling paradigm. We illustrate how the model could be used to obtain the response time of a virtual private network (VPN) service provided by a virtual router (VR)

As models are elevated to first-class artifacts within the software development lifecycle, the task of construction and evolution of large-scale system models becomes a manually intensive effort that can be very time consuming and error prone. To address these problems, this dissertation abstract presents a model transformation approach. There are three main features of this research. First, tasks of model construction and evolution are specified in a model transformation language (called the Embedded Constraint Language). Second, a core transformation engine (called C-SAW) is used to perform model transformation in an automated manner by executing the ECL transformation specification. Finally, testing and debugging tools at the modeling level are provided to assist in detecting errors in the model transformation.

Domain-specific languages (DSLs) assist a domain expert (or end-user) in writing a software program using idioms that are closer to the abstractions found in a specific problem domain. Language tool support for DSLs is lacking, however, when compared to the capabilities provided for standard general purpose languages (e.g., Java and C++). For example, support for debugging and testing a program written in a DSL is often nonexistent. A DSL grammar serves as the primary artifact for defining DSLs from a higher level of abstraction. This paper describes an investigation into a grammar-driven technique to build a testing tool from existing DSL grammars. The DSL grammars are used to generate the hooks needed to interface with a supporting infrastructure written for an Integrated Development Environment (IDE) that assists in debugging and testing a program written in a DSL. We describe a DSL framework that we have implemented to generate DSL testing tools (e.g., debugger and test engine). This framework demonstrates the feasibility and applicability of using the information derived from DSL grammars and existing software components and services to support end-user debugging and testing in a domain friendly programming environment.

This paper introduces a system, called PolyCluster, which adopts state-of-the-art algorithms for data visualization and integrates human domain knowledge into the construction process of classification rules. By utilizing PolyCluster, users can obtain the visual representation for underlying datasets, and utilize that information to draw polygons to encompass wellformed clusters. Each polygon, along with its corresponding projection plane and associated attributes (or dimensions), will be saved as a classification rule, called a PolyRule, for later prediction tasks. Experimental evaluation shows that PolyCluster is a visual-based approach that offers numerous improvements over previous visual-based techniques. It also can help users to obtain additional knowledge from current datasets.

Several new modularity technologies have been proposed that improve separation of concerns in programming languages. The initial efforts to demonstrate these technologies are usually focused on a single programming language. Since we live in a polyglot world, this proposal addresses the goal of being able to take these new powerful technologies to other languages. The approach uses software generators that create new "weavers" from meta-specifications of programming languages.