My technical project is a web-based system design simulator app. Specifically, this project is an educational tool used to bridge the gap between industry expectation and the preparation of entry level software engineers. Through a turn-based simulation, users engage in experiential learning, showing how each decision made influences the immediate steps and system state, as well as how those decisions cascade in the more long-term project context. Each decision triggers a new event, allowing users to choose an option to address a given event. There is no clear âcorrectâ option but instead emphasizes tradeoffs and how those tradeoffs affect system architecture. The system architecture is exposed through two means. First, a metrics panel is presented to a user, with metrics like reliability, architecture complexity, performance, latency, and real-world constraints like budget. Secondly, a software architecture diagram is presented to the user as a main focus of the screen, allowing the user to refer to it for a visual representation of the internal system state as a level of abstraction expected in system design scenarios. Specifically, the software diagram has nodes and edges between the high-level components to represent major parts of a system. Both the metrics panel and software diagram update per decision, showcasing the current system state and highlighting the effect a decision had through. In particular, a slider representing the metrics tracked adjusts (via animation) and also provides color-themed feedback on the state of those metrics (âgoodâ, âwarningâ, âcriticalâ). Depending on the event, the system highlights relevant nodes and edges to indicate to the user where in the system the newest issue is, allowing users to focus on the problem area, but also maintain a perspective of the system at large, as to not lose focus of more long-term goals. The project includes multiple âworldsâ, which simulate a junior software engineer being assigned to a new project, and each world has its own events and action options to take. After playing a session, users can review their decisions to further inform their future decisions. My STS project explores the paths that governance power is redirected through in Decentralized Autonomous Organizations (DAOs). By juxtaposing the DAO imaginary with the realities limited by their implementation in practice, I expose the true outcome of their network. Specifically, I examine how proposed DAO theoretical attributes reveal themselves through a case study of CityDAO. While exploring the lifetime of CityDAO, I apply Actor Network Theory (ANT) to model CityDAO in particular (and DAO processes more broadly) as a network of human and non-human actors. In this network, each actor delegates a level of agency to each other actor it interacts with. I highlight how agency is assigned from each actor to others, and how each actor reshapes the ultimate outcome of the system. However, not all actors are equal. Rather, some actors function as obligatory passage points, through which all proposals must flow and cannot proceed unless this actor allows the proposal to proceed. Through my analysis, I identify membership NFTs, informal member forums, DAO members, DAO leaders, and formal vote signaling tools as actors in this actor network. I also identify multi-signature wallets, registered legal agents, and DAO-oriented legislation as obligatory passage points. By examining this network, I reveal the controlling role that multi-signature wallets, registered legal agents, and supporting DAO legislation plays in the proposal process. These obligatory passage points hold ultimate governance power, since if any of them fail or reject a proposal, the entire system process up until that pointâs intentions are unrealized. While not highly correlated in a direct way, these two projects complement each other by emphasizing system/network level perspectives of visualizing sociotechnical systems and processes. My technical project focuses on users building their understanding of system architecture, while my STS paper reveals the critical points where power lies in the DAO proposal process. Together, the system-building skills learned from the technical project may be applied alongside the strengths and limitations revealed through the network in the STS project to enable us to design systems that more adequately allocate power among all actors moving forward.
Open access
Software Engineering Techniques and Practices
Systems Engineering Methodologies and Applications
Matteo Vaccargiu, Sabrina Aufiero, Silvia Bartolucci, Ronnie de Souza Santos · 6 authors
Labels on platforms such as GitHub support triage and coordination, yet little is known about how well they align with code modifications or how such alignment affects collaboration across contributor experience levels. We present a case study of the Kubernetes project, introducing label-diff congruence - the alignment between pull request labels and modified files - and examining its prevalence, stability, behavioral validation, and relationship to collaboration outcomes across contributor tiers. We analyse 18,020 pull requests (2014--2025) with area labels and complete file diffs, validate alignment through analysis of over one million review comments and label corrections, and test associations with time-to-merge and discussion characteristics using quantile regression and negative binomial models stratified by contributor experience. Congruence is prevalent (46.6\% perfect alignment), stable over years, and routinely maintained (9.2\% of PRs corrected during review). It does not predict merge speed but shapes discussion: among core developers (81\% of the sample), higher congruence predicts quieter reviews (18\% fewer participants), whereas among one-time contributors it predicts more engagement (28\% more participants). Label-diff congruence influences how collaboration unfolds during review, supporting efficiency for experienced developers and visibility for newcomers. For projects with similar labeling conventions, monitoring alignment can help detect coordination friction and provide guidance when labels and code diverge.
Gerardo Iuliano, Daniele Carangelo, Carmine T. Calabrese, Dario Di Nucci
Mutation testing is a technique to assess the effectiveness of test suites by introducing artificial faults into programs. Although mutation testing plugins are available for many platforms and languages, none is currently available for Remix-IDE, the most widely used Integrated Development Environment for the entire contract development journey, used by users of all knowledge levels, and serves as a learning lab for teaching and experimenting with Ethereum. The quality and security of smart contracts are crucial in blockchain systems, as even minor issues can result in substantial financial losses. This paper proposes MuSe, a mutation testing plugin for the Remix-IDE. MuSe includes traditional, Solidity-specific, and security-oriented mutation operators. Its integration into the Remix-IDE eliminates the need for additional setup and lowers the entry barrier. As a result, developers and researchers can immediately leverage mutation testing to assess the effectiveness of their test suites and identify potential issues in smart contracts. We provide a demo video showing MuSe: https://www.youtube.com/watch?v=MIFk9exTDu0 and its repository: https://github.com/GerardoIuliano/MuSe-Remix-Plugin.
Large language models (LLMs) have been widely adopted in modern software development lifecycles, where they are increasingly used to automate and assist code generation, significantly improving developer productivity and reducing development time. In the blockchain domain, developers increasingly rely on LLMs to generate and maintain smart contracts, the immutable, self-executing components of decentralized applications. Because deployed smart contracts cannot be modified, correctness and security are paramount, particularly in high-stakes domains such as finance and governance. Despite this growing reliance, the security implications of LLM-generated smart contracts remain insufficiently understood. In this work, we conduct a systematic security analysis of Solidity smart contracts generated by state-of-the-art LLMs, including ChatGPT, Gemini, and Sonnet. We evaluate these contracts against a broad set of known smart contract vulnerabilities to assess their suitability for direct deployment in production environments. Our extensive experimental study shows that, despite their syntactic correctness and functional completeness, LLM-generated smart contracts frequently exhibit severe security flaws that could be exploited in real-world settings. We further analyze and categorize these vulnerabilities, identifying recurring weakness patterns across different models. Finally, we discuss practical countermeasures and development guidelines to help mitigate these risks, offering actionable insights for both developers and researchers. Our findings aim to support safe integration of LLMs into smart contract development workflows and to strengthen the overall security of the blockchain ecosystem against future security failures.
Smart contracts are high-stakes software: their immutable, publicly accessible, code may govern assets worth millions, meaning that even minor defects can have severe consequences. The most used techniques to ensure smart contract correctness are testing and formal verification. Testing is almost always employed but is often restricted to unit tests (which often miss edge cases) and has limited coverage, while formal verification can provide strong guarantees but is often costly and complex to apply, demanding substantial time and expertise. Property-based testing bridges this gap by exploring large input spaces and shrinking failures to minimal counterexamples, helping uncover defects early in development. Formal verification can be left to critical features once testing has filtered out common issues. To add to the challenges smart contract developers face, most languages used were not designed with safety and security guarantees built-in. Daml is a smart contract language designed with correctness in mind, featuring a strong static type system, functional programming paradigms, and built-in abstractions for common smart contract patterns. However, Daml currently lacks support for property-based testing, limiting developers' ability to systematically explore input spaces and verify contract properties. This paper introduces Hypothesis2Daml, an open-source library that brings property-based testing to the Daml ecosystem by connecting the Hypothesis testing framework with the Daml JSON API. Hypothesis2Daml enables developers to specify invariants, preconditions, and stateful workflows over realistic ledger interactions, while providing automatic input generation, shrinking, and isolation of ledger state between test cases. The approach is evaluated using a benchmark consisting of eight contracts, three Daml templates, and twenty-eight property-based tests covering happy paths, negative cases, and alternative interaction orders. The results show that property-based testing is feasible for Daml smart contracts, can systematically expose violated properties with minimal counterexamples, and supports effective debugging of realistic, stateful workflows.
Microservice architecture has emerged as a dominant paradigm for building largescale software systems, promising modularity, scalability, and independent evolution of services. A central premise of this paradigm is that architectural decomposition reduces inter-service dependencies and enables teams to develop and deploy services autonomously. Despite these expectations, empirical evidence on whether microservice systems actually achieve loose coupling in practice remains limited, particularly in open-source environments where development processes are highly decentralized. This thesis investigates coupling phenomena in microservice-based open-source systems from both technical and organizational perspectives. The research follows a progressive investigative design structured around three stages: <i>measurement, observation</i>, and <i>explanation</i>. First, the thesis introduces the <i>Microservice Logical Coupling</i> (MLC) metric, a repository-based approach for identifying evolutionary dependencies between microservices. By extending traditional logical coupling analysis from file-level artifacts to service-level entities, MLC enables the detection of cross-service evolutionary dependencies using version control data without requiring runtime instrumentation. Second, the thesis conducts a large-scale empirical analysis to assess the prevalence and evolution of logical coupling across microservice-based open-source projects. The results show that logical coupling is a widespread phenomenon and tends to increase over time, suggesting that architectural boundaries alone do not guarantee independent service evolution. Third, the study examines the socio-technical factors associated with coupling by analyzing developer contribution patterns and service ownership structures. The findings reveal a consistent association between cross-service developer activity and higher levels of logical coupling, indicating that organizational structures influence the emerqence of architectural dependencies. Overall, this work contributes a replicable measurement approach, an empirically grounded empirical analysis of coupling in microservices, and a socio-technical perspective on microservice evolution. The results suggest that service independence is not solely an architectural property but a socio-technical outcome shaped by both system design and development practices.
This thesis investigates critical software delivery latency at a large fintech organization, where a modern micro-application architecture was severely bottle-necked by a legacy, manual, ticketing-based approval system. This hybrid environment created an acute organizational bottleneck, imposing high coordination burdens and unpredictable delays on globally distributed feature teams. Using an Action Research (AR) methodology, the study first established a high-friction baseline, measuring the median Lead Time for Changes (LTC) at 20.2 hours. The core intervention involved replacing the mandatory manual approval gate with a fully automated, self-service deployment model integrated directly into the Continuous Integration/Continuous Delivery (CI/CD) pipeline. The intervention successfully drove significant organizational efficiency, yielding a 69% reduction in LTC, dropping the median time from 20.2 hours to 6.2 hours. Concurrently, Deployment Frequency (DF) increased by 213% (from 47 to 100 releases per week). This improvement solidified the organization's position within the DORA elite performance tier. The primary practical guidance derived from this case study is that sustained software acceleration requires prioritizing the decentralization of control over the deployment trigger. This is achieved not merely through technical automation, but by deliberately eliminating all mandatory human coordination steps via external systems (e.g., tickets), relying instead on real-time visibility tooling integrated into the developer workflow. Additionally, and more importantly, this required a complementary organizational culture shift, which involved transfer-ring accountability for production stability directly from administrative roles, such as the Program Manager, to the autonomous development teams.
Abstract Agile fosters speed, autonomy, and innovation at the team level, but organizations often struggle to preserve these strengths as they scale. Coordination overhead increases, decision-making slows, and the agility that once fueled success begins to erode. This paper introduces an approach to scaling by drawing on Robotics Subsumption Architecture , a model originally developed to build adaptive, autonomous robots. Building on the late Mike Beedle âs pioneering work in applying these robotics principles to organization design , we reimagine how to design systems that grow without sacrificing local autonomy or real-time responsiveness. This approach offers scalable agility by embedding sensing, decision-making, and action into every layerâresulting in organizations that are resilient, decentralized, and capable of surviving todayâs VUCA market.
Itzhak Aviv, Alfred Taudesh, Davor SvetinoviÄ, Seok Won Lee
The second International Workshop on Requirement Engineering for Web3 Systems (RE4Web3), held at the 33rd IEEE RE Conference 2025 in Valencia, Spain. RE4Web3 fills in the space between traditional Requirements Engineering (RE) and particular challenges posed by Web3 technologies. Systems based on Web3 engineering principles are transforming software ecosystems with economic tools, transparent ledgers, and decentralized governance. This transition violates assumed expectations in requirements engineering, which mandates adjustments to traditional system engineering frameworks. A research agenda across quantum-safe security, autonomous agent control, socio-technical governance, token incentive design, and supply-chain transparency is advanced in seven peer-reviewed papers.
Smart contract (SC) fuzzing is a critical technique for detecting vulnerabilities in blockchain applications. However, its adoption remains challenging for practitioners due to fundamental differences between SCs and traditional software systems. In this study, we investigate the challenges practitioners face when adopting SC fuzzing tools by conducting an inductive content analysis of 381 GitHub issues from two widely used SC fuzzers: Echidna and Foundry. Furthermore, we conducted a user study to examine how these challenges affect different practitioner groups, SC developers, and traditional software security professionals, and identify strategies practitioners use to overcome them. We systematically categorize these challenges into a taxonomy based on their nature and occurrence within the SC fuzzing workflow. Our findings reveal domain-specific ease-of-use and usefulness challenges, including technical issues with blockchain emulation, and human issues with a lack of accessible documentation and process automation. Our results provide actionable insights for tool developers and researchers, guiding future improvements in SC fuzzer tool design.
The Zupply framework introduces an anonymous authentication protocol that utilizes zero-knowledge proofs to ensure data integrity, participant anonymity, and unlinkability within supply chains. Zupply employed the Groth16 zkSNARK, which requires a trusted setup. This paper explores the integration of Aurora, a transparent setup post-quantum secure zkSNARK, to the Zupply framework. This paper presents the core Zupply arithmetic circuits, including Auth, Trans, Merge, and Div, which allows succinct zero-knowledge proofs without exposing sensitive data. We evaluate the performance of the Zupply Aurora-based implementation across varying Merkle hash tree depths, comparing it to the original Groth16-based setup for BN254 and BLS12-381 elliptic curves.
Abstract- The evolution of blockchain and Web3 technologies has paved the way for decentralized application platforms that enable transparent, tamper-proof transactions without relying on centralized servers. However, existing solutions such as Gitcoin and Giveth are either too complex or unsuitable for modular deployment in educational and lightweight environments. This paper proposes MetaSuite, a role-based, blockchain-driven Software-as-a-Service (SaaS) platform that enables users to create, transfer, and donate tokens while allowing an administrator to securely withdraw funds. Built entirely on the Ethereum blockchain using Solidity smart contracts, MetaSuite operates without a backend and integrates wallet-based authentication via MetaMask and Ethers.js. The platform ensures transparent fund management through on-chain event logging and role-based access controls. Performance evaluations on the Ethereum HoleskyTestnet demonstrate the systemâs reliability, gas-efficiency, and real-time responsiveness. By eliminating backend dependencies and emphasizing traceability, MetaSuite serves as a minimalistic yet scalable Web3 solution suitable for academic, experimental, and small-scale real-world deployments. KeywordsâBlockchain, Web3, Smart Contracts, Ethereum, MetaMask, Tokenization, SaaS, Ethers.js, Decentralized Applications.
This study focuses on automating the formation of ephemeral teams in the search for specialized professionals for software development projects characterized by well-defined requirements. In such cases, it is crucial to identify professionals with the specific skills necessary to meet the projectâs overall needs. Two primary challenges emerge in defining an effective system. The first is the need to standardize the required skills. The second pertains to the application method that candidates should use to apply for specific positions, which should also facilitate automatic evaluation. In the proposed solution, we utilize a system of two smart contracts to ensure automation, security, and transparency in interactions. Additionally, the use of standard frameworks for skills, particularly the SFIA 9 framework, facilitates the precise mapping and classification of both required and possessed skills, aligning candidate selection with project requirements. This approach streamlines the recruitment and selection of ephemeral team members, reducing recruitment time and costs while enhancing the efficiency of software project delivery.
The Hadamard product (also known as element-wise multiplication) is a fundamental operation in linear algebra, performed by multiplying corresponding elements of two matrices with the same dimensions. This operation plays a crucial role in various fields, including cryptography, where it enables efficient and parallelizable computations on large datasetsâparticularly in the design of cryptographic protocols such as zero-knowledge proofs. In this paper, we propose a transparent and efficient method for proving the Hadamard product between vectors that are independently committed in the groups G1and G2under a pairing operation e : G1ĂG2â GT . For a vector of length n, the prover has a complexity ofOλ(n), while the proof size isOλ(logn). The verifier operates with a complexity ofOλ(logn), which includesO(logn) operations in GT and onlyO(1) pairing operations, making verification highly efficient. We prove the security of our scheme under the Symmetric External Diffie-Hellman (SXDH) assumption. Furthermore, we propose an aggregator for Groth16 (EUROCRYPT 2016) zk-SNARKs and a proof aggregation technique for the general case of the KZG polynomial commitment scheme (ASIACRYPT 2010), where all crs are distinct. Both applications do not require an additional trusted setup, support logarithmic-sized aggregated proofs, and significantly reduce the verifierâs pairing operations toO(1).
Darja Ć mite, Nils Brede Moe, Marcin Floryan, Javier GonzĂĄlezâHuerta · 6 authors
While modern software companies strive to increase team autonomy to enable them to successfully operate the piece of software they develop and deploy, efficient ways to orchestrate the work of multiple autonomous teams working in parallel are still poorly understood. In this paper, we report how team autonomy is maintained at Spotify at scale, based on team retrospectives, interviews with team managers and archival analysis of corporate databases and work procedures. In particular, we describe how managerial authority is decentralized through various workgroups with collective authority, what compromises are made to team autonomy to ensure alignment and which team-related factors can further hinder autonomy. Our findings show that scaled autonomy at Spotify does not mean anarchy, or unlimited permissiveness. Instead, squads are expected to take responsibility for their work and coordinate, communicate and align their actions with others, and comply with a few enabling constraints. Further, squads take many decisions independently without management control or due to collective efforts that bypass formal boundary structures. Mechanisms and strategies that enable self-organization at Spotify are related to effective sharing of the codebase, achieving alignment, networking and knowledge sharing, and are described to guide other companies in their efforts to scale autonomy.
Architectural design contexts contain a set of factors that greatly influence software application development. Among them, organizational design contexts consist of high-level company concerns and how it is structured, for example, stakeholders and development schedules heavily impacting design considerations. The Decentralized Autonomous Organization (DAO), as a vital concept in the Web3 space, represents an organization constructed by automatically executed rules, such as via smart contracts, holding features of the permissionless committee, transparent proposals, and fair contribution by participated stakeholders. In this work, we conduct a systematic literature review of existing DAO literature to summarize its structural features, benefits and challenges, and potential development directions in the context of Web3 applications.
Learning heterogeneous graphs consisting of different types of nodes and edges enhances the results of homogeneous graph techniques. An interesting example of such graphs is control-flow graphs representing possible software code execution flows. As such graphs represent more semantic information of code, developing techniques and tools for such graphs can be highly beneficial for detecting vulnerabilities in software for its reliability. However, existing heterogeneous graph techniques are still insufficient in handling complex graphs where the number of different types of nodes and edges is large and variable. This paper concentrates on the Ethereum smart contracts as a sample of software codes represented by heterogeneous contract graphs built upon both control-flow graphs and call graphs containing different types of nodes and links. We propose MANDO, a new heterogeneous graph representation to learn such heterogeneous contract graphsâ structures. MANDO extracts customized meta-paths, which compose relational connections between different types of nodes and their neighbors. Moreover, it develops a multi-metapath heterogeneous graph attention network to learn multi-level embeddings of different types of nodes and their metapaths in the heterogeneous contract graphs, which can capture the code semantics of smart contracts more accurately and facilitate both fine-grained line-level and coarse-grained contract-level vulnerability detection. Our extensive evaluation of large smart contract datasets shows that MANDO improves the vulnerability detection results of other techniques at the coarse-grained contract level. More importantly, it is the first learning-based approach capable of identifying vulnerabilities at the fine-grained line-level, and significantly improves the traditional code analysis-based vulnerability detection approaches by 11.35% to 70.81% in terms of F1-score.
<p indent="0mm">Software is the core component of IT industry and an important âinfrastructureâ that supports social operations in the digital economy era. Since the 21st century, the internet has evolved into a global ubiquitous computing environment and open platform. Its open, dynamic, and uncontrollable nature requires the corresponding changes in the basic form and characteristics of software, the conceptual framework, and the logical connotation, and thus leads to substantial challenges to software theory, methods, and technologies. In 2000, researchers from China proposed the term âinternetwareâ, which indicates a new software paradigm for the internet computing. After more than <sc>20 years</sc> of efforts, a series of important research achievements have been made in aspects of the basic model, development methodology, runtime support, quality assessment and assurance of internetware, and resulted in systematic innovation results and produced a wide range of academic and industrial impacts. In internetware, the software model consists of a set of autonomous software entities distributed and/or decentralized over the internet and other extensions like internet of things and 4G/5G, together with a set of connectors for enabling collaborations among these entities in various ways. Internetware software entities are able to sense dynamic changes of the underlying environments, and continuously adapt to these changes by means of structural and behavioral maintenance and evolution. From the micro perspective, internetware software entities collaborate with each other on demand and on the fly. From the macro perspective, the entities can self-organize to form an application or community of interest and even decentralized autonomous organizations. As a result, the development and evolution of a software application with internetware can be viewed as continuous and iterative composition of various âdisorderedâ resources into âorderedâ software applications. Thus, software development with internetware is a process being bottom-up, inside-out, spiral, and to some extent, similar with the complex adaptive systems. For example, the internetware paradigm proposed the theory of software architecture modeling (called ABC methodology) covering the whole life-cycle, where the core artifacts and activities of every single stage are unified into the software architecture model and its iterative refinement and transformation. In this way, the internetware paradigm greatly improves the efficiency and quality of software development and evolution. In addition, the internetware paradigm expands the software architecture from the development phase to the runtime, by proposing the concept of runtime software architecture (RSA). The RSA has been widely applied for a large number of information âsiloâ systems to enable the functionality and data interoperability. This solution is a significantly disruptive technical invention, or namely the âblack boxâ mode, based on the client-driven resource reflection mechanism to achieve automatic recovery of the system runtime architecture and automatic generation of data access interfaces. Compared to the traditional âwhite boxâ interoperability solution, the internetware paradigm eliminates the need of accessing source code, documentation, and original development team, and improves the interoperability efficiency between information silos, with more than 100X acceleration. This article reviews the research and practice of internetware from the perspective of software paradigm, following the internet computing environment and its extensions as a clue. It also discusses the future research outlook of internetware, especially for the ubiquitous computing environments and data centric technologies.
Seyed Hossein Haeri, Peter Thompson, Neil Davies, Peter Van Roy · 6 authors
This paper directly addresses a critical issue that affects the development of many complex distributed software systems: how to establish quickly, cheaply and reliably whether they will deliver their intended performance before expending significant time, effort and money on detailed design and implementation. We describe &Delta;QSD, a novel metrics-based and quality-centric paradigm that uses formalised outcome diagrams to explore the performance consequences of design decisions, as a performance blueprint of the system. The &Delta;QSD paradigm is both effective and generic: it allows values from various sources to be combined in a rigorous way, so that approximate results can be obtained quickly and subsequently refined. &Delta;QSD has been successfully used by Predictable Network Solutions for consultancy on large-scale applications in a number of industries, including telecommunications, avionics, and space and defence, resulting in cumulative savings of $Bs. The paper outlines the &Delta;QSD paradigm, describes its formal underpinnings, and illustrates its use via a topical real-world example taken from the blockchain/cryptocurrency domain, where application of this approach enabled an advanced distributed proof-of-stake system to meet challenging throughput targets.
The coordination of developing various complex and large-scale projects using computers has been well established and is the so-called computer-supported cooperative work (CSCW). Collaborative software development requires similar technologies and tools to handle the coordination among participating teams. Development of complex and large-scale software systems can be largely improved by effective collaboration among participating software development teams at both component and system levels, which depends on trusted coordination among the participating teams for sharing, processing, and managing information on various participating teams, which are often operating in a distributed environment, even if they are in the same organization. Existing approaches for coordination in collaborative software development are based on using centralized repository and tools to store, process, and retrieve information on participating software development teams during the development. These approaches use centralized authority, have a single point of failure and restricted rights to own data and software. Although there are approaches for collaborative software development using blockchain, they only verify blockchain transactions using customized agreement techniques, and do not address the coordination in collaborative software development. In this paper, it is shown how private blockchain is used to provide trusted coordination in collaborative software development using smart contracts. This is due to the properties of immutability, auditability, and transparency of the blockchain.