103 research outputs found
Solving package dependencies: from EDOS to Mancoosi
Mancoosi (Managing the Complexity of the Open Source Infrastructure) is an
ongoing research project funded by the European Union for addressing some of
the challenges related to the "upgrade problem" of interdependent software
components of which Debian packages are prototypical examples. Mancoosi is the
natural continuation of the EDOS project which has already contributed tools
for distribution-wide quality assurance in Debian and other GNU/Linux
distributions. The consortium behind the project consists of several European
public and private research institutions as well as some commercial GNU/Linux
distributions from Europe and South America. Debian is represented by a small
group of Debian Developers who are working in the ranks of the involved
universities to drive and integrate back achievements into Debian. This paper
presents relevant results from EDOS in dependency management and gives an
overview of the Mancoosi project and its objectives, with a particular focus on
the prospective benefits for Debian
Description of the CUDF Format
This document contains several related specifications, together they describe
the document formats related to the solver competition which will be organized
by Mancoosi. In particular, this document describes: - DUDF (Distribution
Upgradeability Description Format), the document format to be used to submit
upgrade problem instances from user machines to a (distribution-specific)
database of upgrade problems; - CUDF (Common Upgradeability Description
Format), the document format used to encode upgrade problems, abstracting over
distribution-specific details. Solvers taking part in the competition will be
fed with input in CUDF format
Strong Dependencies between Software Components
Component-based systems often describe context requirements in terms of
explicit inter-component dependencies. Studying large instances of such
systems?such as free and open source software (FOSS) distributions?in terms of
declared dependencies between packages is appealing. It is however also
misleading when the language to express dependencies is as expressive as
boolean formulae, which is often the case. In such settings, a more appropriate
notion of component dependency exists: strong dependency. This paper introduces
such notion as a first step towards modeling semantic, rather then syntactic,
inter-component relationships. Furthermore, a notion of component sensitivity
is derived from strong dependencies, with ap- plications to quality assurance
and to the evaluation of upgrade risks. An empirical study of strong
dependencies and sensitivity is presented, in the context of one of the
largest, freely available, component-based system
Evolution in the Debian GNU/Linux software network : analogies and differences with gene regulatory networks
Biological networks exhibit intricate architectures deemed to be crucial for their functionality. In particular, gene regulatory networks, which play a key role in information processing in the cell, display non-trivial architectural features such as scale-free degree distributions, high modularity and low average distance between connected genes. Such networks result from complex evolutionary and adaptive processes difficult to track down empirically. On the other hand, there exists detailed information on the developmental (or evolutionary) stages of open-software networks that result from self-organized growth across versions. Here, we study the evolution of the Debian GNU/Linux software network, focusing on the changes of key structural and statistical features over time. Our results show that evolution has led to a network structure in which the out-degree distribution is scale-free and the in-degree distribution is a stretched exponential. In addition, while modularity, directionality of information flow, and average distance between elements grew, vulnerability decreased over time. These features resemble closely those currently shown by gene regulatory networks, suggesting the existence of common adaptive pathways for the architectural design of information-processing networks. Differences in other hierarchical aspects point to system-specific solutions to similar evolutionary challenges
Designing Programming Languages for Writing Maintainable Software
Maintainability is crucial to the long-term success of software projects. Among other factors, it is affected by the programming language in which the software is written. Programming language designers should be conscious of how their design decisions can influence software maintainability. Non-functional properties of a language can affect the readability of source code in ways beyond the control of programmers. Language features can cause or prevent certain classes of bugs, and runtime issues especially can require significant maintenance effort. Tools external to the language, especially those developed and distributed by language implementers, can aid in the creation of maintainable software. Languages designed with these aspects in mind will ease the burden placed on software maintainers by facilitating the development of robust, high-quality software
Making data-driven porting decisions with Tuscan
Software typically outlives the platform that it was originally written for. To smooth the transition to new tools and platforms, programs should depend on the underlying platform as little as possible. In practice, however, software build processes are highly sensitive to their build platform, notably the implementation of the compiler and standard library. This makes it difficult to port existing, mature software to emerging platforms-web based runtimes like WebAssembly, resource-constrained environments for Internet-of-Things devices, or innovative new operating systems like Fuchsia. We present Tuscan, a framework for conducting automatic, deterministic, reproducible tests on build systems. Tuscan is the first framework to solve the problem of reproducibly testing builds cross-platform at massive scale.We also wrote a build wrapper, Red, which hijacks builds to tolerate common failures that arise from platform dependence, allowing the test harness to discover errors later in the build. Authors of innovative platforms can use Tuscan and Red to test the extent of unportability in the software ecosystem, and to quantify the effort necessary to port legacy software. We evaluated Tuscan by building an operating system distribution, consisting of 2,699 Red-wrapped programs, on four platforms, yielding a 'catalog' of the most common portability errors. This catalog informs data-driven porting decisions and motivates changes to programs, build systems, and language standards; systematically quantifies problems that platform writers have hitherto discovered only on an ad-hoc basis; and forms the basis for a common substrate of portability fixes that developers can apply to their software
Applying Package Management To Mod Installation
Package management automates the discovery and installation of software that can coexist within an operating system. The methods used by package management can also address other instances where the installation of software needs to be automated. One example of this is the environment produced by third party video game modifications. An adapted application of package management practices can help to solve the difficult problem of finding and installing a set of video game modifications that do not conflict with each other. This greatly benefits the environment by allowing third party contributions to be easily installed which fosters growth in both the developer and user community surrounding the environment. This thesis presents the theory and complexities behind package management and shows how it can be effectively applied to managing video game modifications by presenting examples of software that can extract relevant metadata from video game modifications and discover conflict free installation solutions
- …