In this project, students will explore the fundamentals of machine learning applied to a space weather example through a hands-on activity. By using the space weather domain, this lesson can also be applied to general science standards. Using Google's Teachable Machine, students create an image classification model that can recognize and differentiate between key space weather phenomena such as auroras, solar flares, and sunspots. This accessible approach introduces real-world applications of AI in science while helping students build practical skills in data analysis and pattern recognition. Students then deploy their models using a simple web application built with HTML and JavaScript. This combined assignment allows students to gain firsthand experience with advanced machine learning concepts, including model inference, confidence scores, and integrating models into digital tools. Designed for high school and introductory computer science courses, the project requires minimal technical setup and is adaptable to various levels. Students not only learn the basics of machine learning, such as how training data works, why class balance matters, and how to test with new examples, but also strengthen their coding skills by customizing and debugging their own web apps. For more advanced students, optional extension activities introduce topics such as user interface design, artificial intelligence ethics, and the impact of space weather on the technology we rely on every day.

In this lightning talk, we discuss the creation of an initial G6-12 unit that traces how fundamentals of coding have evolved in response to socio-economic-political and technological motivators. The unit employed unplugged strategies to enhance students' grasp of core computer science principles and spark deeper engagement and conceptual understanding. Lessons were designed. We designed the unit so lessons can be used alone or part of a larger experience. While these lessons were created separately and used independently, the cohort collaboratively reflected and observed that technological advancements consistently build upon prior practices and habits, revealing interconnected developments that unfold over time. The impetus for this research has also been influenced by Meadow's work on communication throughout the ages, which explains coding in a similar manner. The complexity of communications progressively increases, yet the systems developed rely on simple, repeatable patterns regardless of whether they appear in the historical timeline. Examples of these communications include smoke signals, Morse code, and spectral imaging. Even binary code, a basic language composed of only two characters (0s and 1s), enables the creation of complex and sophisticated communication technologies. For example, the computational spectral imaging lesson immerses students in binary code and data representation through unplugged pixel art activities that simulate the transmission of satellite images, illustrating how simple patterns form the foundation of complex computing systems. In addition, the lesson supports the unifying theme by connecting historical communication methods to modern coding practices, revealing the continuity of technological evolution across time.

In today's rapidly changing technological landscape, it is becoming increasingly evident that solar weather, simulations, and artificial intelligence (AI) are topics that can be and should be integrated into middle school education. Solar weather events can create massive problems with climate, communication, and technology, problems that can be alleviated by prediction. These events generate massive amounts of data that AI can use for such prediction. These topics can be introduced through simulations. How can we integrate solar weather data and simulations with AI-driven models to create interactive and educational software? This paper reviews lessons and pedagogical approaches used to teach about solar weather, AI and incorporate simulations to integrate CS concepts into other middle school subject areas. The research supports year one of a three-year project. The length of the project allows time to develop a progression to introduce CS concepts and the development of a simulation that can be used in a variety of middle school classrooms.

In the era of artificial intelligence (AI), generative AI, and Large Language Models (LLMs) in particular, have become increasingly significant in various sectors. LLMs such as GPT expand their applications, from content creation to advanced code completion. They offer unmatched opportunities but pose unique challenges to the software engineering domain. This paper discusses the necessity and urgency for software engineering education to adapt and evolve to prepare software engineers for the emerging LLM environment. While existing literature and social media have investigated AI's integration into various educational spheres, there is a conspicuous gap in examining the specifics of LLMs' implications for software engineering education. We explore the goals of software engineering education, and changes to software engineering, software engineering education, course pedagogy, and ethics. We argue that a holistic approach is needed, combining technical skills, ethical awareness, and adaptable learning strategies. This paper seeks to contribute to the ongoing conversation about the future of software engineering education, emphasizing the importance of adapting and evolving to remain in sync with rapid advancements in AI and LLMs. It is hoped that this exploration will provide valuable insights for educators, curriculum developers, and policymakers in software engineering.

States are moving to adopt Computer Science (CS) education standards to help K-12 teachers adapt and integrate computing /computational thinking (CT) concepts into the curriculum. These approaches also rely heavily on training current and pre-service teachers and creating opportunities to learn CS while also managing the rigors of their education career. This poster presents elements of the collaboration between the Department of CS and Department of Teaching and Learning at Montclair State University (MSU) to bring CS to pre- and in-service educators. Here we will highlight our curriculum work and professional development (PD) series. The New Jersey (NJ) Department of Education has adopted CS Education standards for K-12 and distinctly funded curriculum development and faculty formation programs. MSU has built programs that support teachers through PD experiences in CT and CS. In the 10-month period ending March 2023, we will offer 30 PD opportunities for a CS and CS education. To date, more than 200 educators have received PD to address their educational needs regarding CS curricula.

Contact: [email protected] The United States does not produce sufficient numbers of well-qualified professionals in STEM, and in computing/ technology in particular. The number of students pursuing undergraduate degrees in computer science or related field continues to grow but is still not pacing industry growth. Employers repeatedly suggest that good professional and technical competencies, including "soft skills", are a major factor in both obtaining and succeeding in STEM careers. Moreover, both the Council on Graduate Studies and the National Science Board in the NSF 2018 STEM Trends report support the need of such skills for success in STEM. These competencies comprise (1) communication, oral and written, and in technical, business and general settings; (2) working in and leading teams, in varying roles; (3) managing business and professional relationships; (4) planning, problem solving, and critical thinking; (5) mathematical capabilities including numeracy; and (6) an understanding of ethical, social, managerial, and economic perspectives; plus, responding to recent developments in science and science careers, (7) an interdisciplinary perspective and overview understanding of data science. In this poster we present a proposal for a post baccalaureate certificate curriculum, which we suggest also assists students transitioning from other fields, and can be applied more widely across STEM.

Courses in Relational Databases largely use a domain-specific design approach different from that used in the rest of the curriculum. Use of the Unified Process, UML, and Design Patterns as a pedagogical approach for Databases can leverage previous student experience with design, make knowledge from Database courses more immediately relevant elsewhere, and create greater continuity across the curriculum. This approach allows issues in logical design and in implementation to be more easily connected with similar concerns in other courses (for example, Software Engineering), and supports greater and easier transfer of design between Relational and Object-Oriented Databases, and between databases and embedding applications.

Engineering of complex distributed real-time applications is one of the hardest tasks faced by the software profession today. All aspects of the process, from design to implementation, are made more difficult by the interaction of behavioral and platform constraints. Providing tools for this task is likewise not without major challenges. In this paper, we discuss a tool suite which supports the development of complex distributed real-time applications in a suitable high-level language (CRL). The suite's component tools include a compiler, a transformer-optimizer, an allocator-migrator, a schedulability analyzer, a debugger-monitor, a kernel, and a (simulated) network manager. The overall engineering approach supported by the suite is to provide as simple and natural an integrated development paradigm as possible. The suite tools address complexity due to distribution, scheduling, allocation and other sources in an integrated manner (largely) transparent to the developer. To reflect the needs of propagation of functional and nonfunctional requirements throughout the development process, a number of robust code transformation and communication mechanisms have been incorporated into the suite. To facilitate practical use of the suite, the developed programs compile-transform to a safe subset of C++ with appropriate libraries and runtime support. (In this safe subset (C++) the use of pointers is minimized. Aliases are not allowed.

Deterministic worst-case execution for satisfying hard-real-time constraints, and speculative execution with rollback for improving average-case throughput, appear to lie on opposite ends of a spectrum of performance requirements and strategies. Nonetheless, we show that there are situations in which speculative execution can improve the performance of a hard real-time system, either by enhancing average performance while not affecting the worst-case, or by actually decreasing the worst-case execution time. The paper proposes a set of compiler transformation rules to identify opportunities for speculative execution and transform the code. Moreover, we have conducted an extensive experiment using simulation of randomly generated real-time programs to evaluate applicability and profitability of speculative execution. The simulation results indicate that speculative execution improves average execution time and program timeliness. Finally, a prototype implementation is described in which these transformations have been evaluated for realistic applications.

The integration of system and SW functions for efficiency, performance and especially dependability is of interest from a research and system design perspective. We propose a framework for directing the process of integration of SW functions, with the objective of designing and maintaining desired dependability attributes of the system over the integration process. Rules of composition for integrated functions, and measures to quantify the goodness of dependable system integration are also addressed.

Engineering of complex distributed real-time applications is one of the hardest tasks faced by the software profession today. All aspects of the process, from design to implementation, are made more difficult by the interaction of behavioral and platform constraints. Providing tools for this task is likewise not without major challenges. In this paper, we discuss a tool suite at New Jersey Institute of Technology's Real-Time Computing Lab which supports the development of complex distributed real-time applications in a suitable high-level language (CRL). The suite's component tools include a compiler, a transformer-optimizer, an allocator-migrator, schedulability analyzers, a debugger-monitor, a kernel, and a (simulated) network manager. The overall engineering approach supported by the suite is to provide as simple and natural an integrated development paradigm as possible. The suite tools address complexity due to distribution, scheduling, allocation and other sources in an integrated manner (largely) transparent to the developer. To reflect the needs of propagation of functional and non-functional requirements throughout the development process, a number of robust code transformation and communication mechanisms have been incorporated into the suite. To facilitate practical use of the suite, the developed programs compile-transform to a safe subset of C++ with appropriate libraries and runtime support.

A general model for traffic flows on packet-switched, virtual-circuit based, fixed-packet networks is introduced, and an exact schedulability test is obtained for systems of such flows. Rules are derived that make the evaluation of this schedulability test feasible and efficient under certain circumstances. The practical relevance of this approach is demonstrated by applying it to a number of standard traffic models.

The problem of non-preemptively scheduling a set of n tasks on m identical processors with communication overhead subject to precedence and deadline constraints is considered. A new heuristic with the time complexity of O(n/sup 2/m), Least Space-Time First (LSTF), is proposed to minimize the maximum tardiness. From simulation results, it is shown that LSTF outperforms other heuristic algorithms.

The overhead of the general checkpointing approach is infeasible for distributed real-time systems where timing is critical. We present a new compiler based approach which classifies data, and minimizes the data needed for checkpointing using static data flow analysis and language support. Our approach provides static guarantees of timeliness while checkpointing, and explores timely recovery for real-time systems. We outline our approach and discuss the necessary architecture and language support needed to make this feasible.

The paper introduces the RTM task graph model. RTM is a distributed operating system and scheduler for complex real time tasks developed at the University of Illinois, Urbana-Champaign, with a medium grained data flow model of computation. Tasks are linearly segmented (possibly with loops), but have arbitrary interconnectivity. This allows for decomposable tasks while avoiding the complications of a full fledged hierarchical model, simplifying scheduling, resource allocation. Our description of the task graph model in RTM can largely also be viewed as a list of desirable characteristics of any task graph based environment for real time design and implementation.

Compiler optimization techniques have been applied to facilitate development and performance timing of non-real-time systems. Unfortunately, regular compiler optimization can complicate the analysis and destroy timing properties of real-time systems. This paper discusses the difficulties of performing compiler optimization in distributed real-time systems. An algorithm is presented to apply machine-independent compiler optimization safely to distributed real-time systems. The algorithm uses resources' busy-idle profiles to investigate effects of optimizing one process on other processes. A restricted form of resource contention is assumed to simplify the analysis.

A complex application consists of a set of software modules, executed on a distributed system, guided by requirements imposed by the designer and the system. The REAL project at NJIT has been investigating the resource allocation problem for such a system. We give a classification of and syntax for constraints, provide a rule-based approach for constraint management, and discuss issues in generating implied constraints and consistency checking.

Achieving fault-tolerance using a primary-backup approach involves overhead of recovery such as activating the backup and propagating execution states, which may affect the timeliness properties of real-time systems. We propose a semi-passive architecture for fault-tolerance and show that speculative execution can enhance overall performance and hence shorten the recovery time in the presence of failure. The compiler is used to detect speculative execution, to insert check-points and to construct the updated messages. Simulation results are reported to show the contribution of speculative execution under the proposed architecture.

The new generation of real-time systems are characterized by multiple, conflicting non-functional desiderata on goals. Furthermore, the systems exhibit very large size and complexity—in both application structures and underlying software and hardware platforms. We argue that current high-level real-time languages do not meet the challenge of these complex real-time systems and introduce a new language—CRL—that we claim does. Relevant real-time features of CRL are discussed and a summary is provided vis-à-vis future features that would address non-functional goals other than timeliness. A current implementation status and how CRL fits into a rather ambitious environment for the construction of complex real-time systems (under construction in our Real-Time Computing Lab at NJIT) are briefly presented.

Multisource data flow problems involve information which may enter nodes independently through different classes of edges. In some cases, dissimilar meet operations appear to be used for different types of nodes. These problems include bidirectional and flow-sensitive problems as well as many static analyses of concurrent programs with synchronization. K-tuple frameworks , a type of standard data flow framework, provide a natural encoding for multisource problems using a single meet operator. Previously, the solution of these problems has been described as the fixed point of a set of data flow equations. Using our k -tuple representation, we can access the general results of standard data flow frameworks concerning convergence time and solution precision for these problems. We demonstrate this for the bidirectional component of partial redundancy suppression and two problems on the program summary graph. An interesting subclass of k -tuple frameworks, the join-of-meets frameworks, is useful for reachability problems, especially those stemming from analyses of explicitly parallel programs. We give results on function space properties for join-of-meets frameworks that indicate precise solutions for most of them will be difficult to obtain.

Deterministic worst-case execution to satisfy hard real-time constraints, and speculative execution with rollback to improve average-case throughput, appear to lie on opposite ends of a spectrum of performance requirements and strategies. Nonetheless, we show there are situations in which speculative execution can probably improve the performance of a hard real-time system, either by improving average performance while not affecting the worst case, or by actually decreasing worst-case execution time. We also show how related strategies for partial or total precomputation can lead to improved performance. Finally, we discuss possible compiler transformations to detect chances of profitable speculative execution.>

This paper introduces Composable Attribute Grammars (CAGs), a formalism that extends classical attribute grammars to allow for the modular composition of translation specifications and of translators. CAGs bring to complex translator writing systems the same benefits of modularity found in modern programming languages, including comprehensibility, reusability, and incremental meta-compilation.A CAG is built from several smaller component AGs, each of which solves a particular subproblem, such as name analysis or register allocation. A component AG is based upon a simplified phrase-structure that reflects the properties of its subproblem rather than the phrase-structure of the source language. Different component phrase-structures for various subproblems are combined by mapping them into a phrase-structure for the source language. Both input and output attributes can be associated with the terminal symbols of a component AG. Output attributes enable the results of solving a subproblem to be distributed back to anywhere that originally contributed part of the subproblem, e.g. transparently distributing the results of global name analysis back to every symbolic reference in the source program.After introducing CAGs by way of an example, we provide a formal definition of CAGs and their semantics. We describe a subclass of CAGs and their semantics. We describe a subclass of CAGs, called separable CAGs, that have favorable implementation properties. We discuss the novel aspects of CAGs, compare them to other proposals for inserting modularity into attribute grammars, and relate our experience using CAGs in the Linguist translator-writing system.

Our exhaustive and incremental hybrid data flow analysis algorithms, based on iteration and elimination techniques, are designed for incremental update of a wide variety of monotone data flow problems in response to source program changes. Unlike previous incremental iterative methods, this incremental algorithm efficiently computes precise and correct solutions. We give theoretical results on the imprecision of restarting iteration for incremental update by fixed point iteration which provided motivation for our algorithm design. Described intuitively, the main algorithm idea is to factor the data flow solution on strong connected components of the flow graph into local and external parts, solving for the local parts by iteration and propagating these effects on the condensation of the flow graph to obtain the entire data flow solution. The incremental hybrid algorithm re-performs those algorithm steps affected by the program changes.

The authors have designed a family of parallel dataflow analysis algorithms for execution on a message-passing MIMD (multiple instruction multiple data) architecture, based on general purpose, hybrid dataflow analysis algorithms. They have exploited the natural task partitioning of the hybrid algorithms and have explored a static mapping-dynamic scheduling strategy. Alternative mapping-scheduling choices and refinements of the flow graph condensation utilized are discussed. This parallel hybrid algorithm family is illustrated on the reaching definitions problem, although parallel algorithms also exist for many interprocedural (e.g., aliasing) and intraprocedural (e.g., available expressions) problems.>