We propose a novel two-stage framework, Coarse-to-Fine Part Assembly (CFPA), for 3D shape assembly from basic parts. Effective part assembly demands precise local geometric reasoning for accurate component assembly, as well as global structural understanding to ensure semantic coherence and plausible configurations. CFPA addresses this challenge by integrating semantic abstraction and symmetry-aware reasoning into a unified pose prediction process. In the first stage, semantic super-parts are constructed via an optimal transport formulation to capture high-level object structure, which is then propagated to individual parts through a dual-range feature propagation mechanism. The second stage refines part poses via cross-stage feature interaction and instance-level geometric encoding, improving spatial precision and coherence. To enable diverse yet valid assemblies, we introduce a symmetry-aware loss that jointly models both self-symmetry and inter-part geometric similarity, allowing for diverse but structurally consistent assemblies. Extensive experiments on the PartNet benchmark demonstrate that CFPA achieves state-of-the-art performance in assembly accuracy, structural consistency, and diversity across multiple categories.

Project-based learning is a critical component of software engineering education, particularly in senior design or capstone courses where students collaborate on real-world projects.However, evaluating individual contributions and maintaining healthy team dynamics remain persistent challenges.Issues such as social loafing, uneven workload distribution, and subjective grading hinder both student outcomes and instructional effectiveness.This paper presents Project Pulse, a webbased platform designed to enhance transparency, accountability, and feedback in team-based software projects.By automating weekly activity reporting and structured peer evaluations, Project Pulse provides real-time insights into individual and team performance, allowing instructors to detect problems early and assess contributions more fairly.The platform has been deployed in a year-long senior design course involving 50 students across 8 teams.Survey results indicate improved student accountability, enhanced collaboration, and reduced administrative overhead for instructors.Project Pulse is open source, publicly accessible at https://projectpulse.team, and demonstrates how software engineering tools can be applied to improve software engineering education itself.A short demo video showcasing key features is available at https://youtu.be/ASaR3UdrwKg.

The pervasive use of textual formats in the documentation of software requirements presents a great opportunity for applying large language models (LLMs) to software engineering tasks. High-quality software requirements not only enhance the manual software development process but also position organizations to fully harness the potential of the emerging LLMs technology. This paper introduces a tailored LLM for automating the generation of code snippets from well-structured requirements documents. This LLM is augmented with knowledge, heuristics, and instructions that are pertinent to the software development process, requirements analysis, object-oriented design, and test-driven development, effectively emulating the expertise of a seasoned software engineer. We introduce a “Progressive Prompting” method that allows software engineers to engage with this LLM in a stepwise manner. Through this approach, the LLM incrementally tackles software development tasks by interpreting the provided requirements to extract functional requirements, using these to create object-oriented models, and subsequently generating unit tests and code based on the object-oriented designs. We demonstrate the LLM's proficiency in comprehending intricate user requirements and producing robust design and code solutions through a case study focused on the development of a web project. This study underscores the potential of integrating LLMs into the software development workflow to significantly enhance both efficiency and quality. The tailored LLM is available at https://chat.openai.com/g/g-bahoiKzkB-software-engineer-gpt.

Java-based applications are widely used by companies, government agencies, and financial institutions. Every day, these applications process a considerable amount of sensitive data, such as people's credit card numbers and passwords. Research has found that the Java Virtual Machine (JVM), an essential component for executing Java-based applications, stores data in memory for an unknown period of time even after the data are no longer used. This mismanagement of JVM puts all the data, sensitive or non-sensitive, in danger and raises a huge concern to all Java-based applications globally. This problem has serious implications for many “secure” applications that employ Java-based frameworks or libraries with a severe security risk of having sensitive data that attackers can access after the data are thought to be cleared. This paper presents a prototype of a secure Java API we design through an undergraduate student research project. The API is implemented using direct Byte buffer so that sensitive data are not managed by JVM garbage collection. We also implement the API using obfuscation so that data are encrypted. Using an initial experimental evaluation, the proposed secure API can successfully protect sensitive data from being accessed by malicious users.

Context and motivation: Multiple-viewed requirements modeling method describes the system to-be from different perspectives. Some requirements models are then specified in various UML diagrams. Question/problem: Managing those models can be tedious and error-prone, since a lot of CASE tools provide poor support for reasoning and consistency checking. Principal ideas/results: Ontology is a formal notation for describing concepts and their relations in a domain. Since software requirements are a kind of knowledge, we propose to adopt a knowledge engineering approach for managing the consistency of requirements models. In this paper, an ontology for three most commonly used UML diagrams is developed in Web Ontology Language (OWL). The transformation of UML class, sequence and state diagrams to OWL knowledge base is presented. Owing to the underlying logical reasoning capability of OWL, a semantic query language, SPARQL (SPARQL Protocol and RDF Query Language), is used to query the knowledge base for consistency checking. Contribution: This paper introduces a semantic web-based knowledge engineering approach to represent and manage software requirements knowledge in OWL. By experimenting with a concrete software system, we demonstrate the feasibility and applicability of this knowledge approach.

Program monitoring aims at making sure the functionalities of the software are always correctly performed during runtime. Semantic Web provides a context enriched framework for data representation and manipulation. This paper proposed the use of ontological rules and reasoning engines to monitor the dynamic behaviours of computer systems in handling of exceptional circumstances, both positive and negative, that occur at runtime within the software processes. A prototype framework was proposed on how to integrate the rule based monitoring technique together with the targeted system. To validate the proposed solution, a light control system case study together with the Unity game engine were used to develop a simulation environment for the evaluation purpose. Compared to existing solutions, the approach outlined can provide an effective software behavioural monitoring outcome.

Security vulnerabilities and software defects are prevalent in software systems, threatening every aspect of cyberspace. The complexity of modern software makes it hard to secure systems. Security vulnerabilities and software defects become a major target of cyberattacks which can lead to significant consequences. Manual identification of vulnerabilities and defects in software systems is very time-consuming and tedious. Many tools have been designed to help analyze software systems and to discover vulnerabilities and defects. However, these tools tend to miss various types of bugs. The bugs that are not caught by these tools usually include vulnerabilities and defects that are too complicated to find or do not fall inside of an existing rule-set for identification. It was hypothesized that these undiscovered vulnerabilities and defects do not occur randomly, rather, they share certain common characteristics. A methodology was proposed to detect the probability of a bug existing in a code structure. We used a comprehensive experimental evaluation to assess the methodology and report our findings.

Multiple-viewed requirements modeling allows requirement engineers to acquire the requirements of a system from different perspectives.Requirements are then specified in various UML models.Maintaining the requirements knowledge encoded in UML notations is tedious and error-prone, since most UML CASE tools provide poor support for reasoning and query.Ontology is a formal notation for describing concepts and their relations in a domain.Since requirement is a kind of knowledge, we propose to use knowledge engineering approach for managing the consistency and completeness of UML models.In this paper, an ontology for UML diagrams is coded in a semantic web language, OWL (Web Ontology Language).The transformation of UML Class Diagram, Sequence Diagram and State Diagram to OWL knowledge base is presented.In the end, a semantic query language, SPARQL, is used to query the knowledge base.We demonstrate the feasibility of this approach through an example software system.

Multiple-viewed requirements modeling allows modelers to elicit the requirements of a system from different viewpoints.Requirements are then organized and encoded in different analysis models which collaboratively form an overall understanding of the system.Model transformations among those analysis models at this stage can be used as a way to acquire requirements knowledge, thus making the set of models complete and consistent.Two frameworks are found to support such requirements acquisition: the pairwise framework and the common representation framework.In practical applications, various factors need to be considered when requirements modelers choose between the two frameworks in order to acquire requirements by analysis model transformations.In this paper, we propose a set of criteria which provides a theoretical basis for comparing the two frameworks for their effectiveness of generating models and acquiring requirements in the context of multiple-viewed requirements modeling.The results of the comparison is then presented.

Students that first learn multiple-viewed requirements modeling with UML diagrams tend to create incomplete and inconsistent models. Complex requirements and numerous modeling elements in UML often overwhelm students and make it hard for them to even notice such flaws in the models. Useful feedback can help students revise their UML models to be more complete. In this paper, we introduce a novel approach of teaching UML modeling and requirements acquisition. A knowledge-based framework is proposed to help reveal incompleteness and inconsistency in a set of models developed by students. This approach can drive the process of acquiring requirements for each UML model. The proposed framework is based on a central knowledge representation, the conceptual graphs.