Quantum Software, its engineering and its applications are becoming more and more indispensable components of the current knowledge baggage of researchers and industrial professionals. Given the continuous accelerating developments of Quantum Computing, and the vastness of available knowledge, one needs efficient methods to dedicate the limited available personal time to the correct choice of selective information. This Special Issue on “Quantum Computing and Software Engineering” offers a small, but diverse set of papers covering theoretical, practical software system design and a pragmatic survey of Quantum Software Engineering, being a map pointing to references of relevance, aiming to answer the issue of choice of selective information.

It is widely understood that quantum computing — quantum gates upon qubits — is the general case, encompassing computing by classical means, viz. Boolean logic upon classical bits. It also seems reasonable that Quantum Software should encompass Classical Software. However, to accept such a statement regarding software, the feeling that it seems reasonable is not enough. One needs clear-cut definitions and formal conclusions. This is exactly the purpose of this paper. Previously, we have represented Classical Software by the Laplacian Matrix. More recently, we have shown that Quantum Software is faithfully represented by Density Matrices. It turns out that a Laplacian Matrix normalized by the Laplacian Trace easily obtains a Density Matrix. This opens the horizons for Quantum Software operations — such as unitary and reversible evolution — not naturally available with the classical Laplacian. This paper provides the necessary definitions and conclusions, illustrating the more general Quantum operations with a relevant case study, playing the double role of both classical and quantum software.

Quantum Tomography partially measures and then recovers the remaining density matrix quantum state, in order to verify that a certain device -processor or detector -indeed outputs the intended quantum state.However, single matrix element measurements rapidly increase in number with the density matrix dimension and are error-prone.This work proposes a novel quantum software viewpoint on quantum tomography.Instead of individual matrix elements, measurements and density matrix recovery are performed on higher-abstraction modules, i.e. semantically meaningful groups of matrix elements.Quantum Modules Tomography potentially reduce the necessary number of explicit measurements, while still allowing recovery of the whole density matrix.A Recovery Theorem is formulated and proved: density matrix diagonal measurements suffice to recover the whole system density matrix, in terms of modules.The recovery procedure is illustrated by a few case studies.

Quantum Software Models is a theoretical framework to systematically design and analyze any software system -be it quantum, classical or hybrid -representing it by a design Density Matrix.Recently, we have demonstrated a top-down approach, to decompose a whole software system Density Matrix into modules, using basis vector projectors of the Matrix.However, it would be even more natural to have a systematic bottom-up procedure, to compose a whole software system Density Matrix, given a set of well-designed software module matrices, taken as sub-systems.This is exactly the paper's purpose.The result obtained: the whole software system Density Matrix is a perfect Direct Sum of module density matrices.This result yields clear software design benefits: it is bidirectional, one can traverse the software system hierarchy top-down or bottom-up, in particular, gradually building up the whole system from verified correct modules, assured by spectral decoupling techniques.The claim is formally validated and is illustrated by software system studies.

The unrelenting trend of larger and larger sizes of Software Systems and data has made software comprehensibility an increasingly difficult problem. However, a tacit consensus that human understanding of software is essential for most software related activities, stimulated software developers to embed comprehensibility in their systems’ design. On the other hand, recent empirical successes of Deep Learning neural networks, in several application areas, seem to challenge the tacit consensus: is software comprehensibility a necessity, or just superfluous? This introductory paper, to the 2020 special issue on Theoretical Software Engineering, offers reasons justifying our standpoint on the referred controversy. This paper also points out to specific techniques enabling Human Understanding of software systems relevant to this issue’s papers.

Well-designed software systems, with providers only modules, have been rigorously obtained by algebraic procedures from the software Laplacian Matrices or their respective Modularity Matrices. However, a complete view of the whole software system should display, besides provider relationships, also consumer relationships. Consumers may have two different roles in a system: either internal or external to modules. Composite modules, including both providers and internal consumers, are obtained from the joint providers and consumers Laplacian matrix, by the same spectral method which obtained providers only modules. The composite modules are integrated into a whole Software System by algebraic connectors. These algebraic connectors are a minimal Occam’s razor set of consumers external to composite modules, revealed through iterative splitting of the Laplacian matrix by Fiedler eigenvectors. The composite modules, of the respective standard Modularity Matrix for the whole software system, also obey linear independence of their constituent vectors, and display block-diagonality. The spectral method leading to composite modules and their algebraic connectors is illustrated by case studies. The essential novelty of this work resides in the minimal Occam’s razor set of algebraic connectors — another facet of Brooks’ Propriety principle leading to Conceptual Integrity of the whole Software System — within Linear Software Models, the unified algebraic theory of software modularity.

Software modularity by pinpointing and subsequent resolution of the remaining coupling problems is often assumed to be a general approach to optimize any software system design. However, software coupling types with differing specific characteristics, seemingly pose serious impediments to any generic coupling resolution approach. Despite the diversity of types, this work proposes a generic approach to solve any coupling type in three steps: a-obtain the Dependency graph for the coupled modules; b-convert the dependency graph into a Bipartite Graph; c-generate the Laplacian Matrix from the Bipartite Graph. Coupling problems to be resolved are then located, using Laplacian eigenvectors, in particular the Fiedler eigenvector. The generic approach is justified, explained in detail, and illustrated by a few case studies.

It is an empirical observation that Software Engineering and Knowledge Engineering seem to converge to a single discipline which may be suitably called Software-Knowledge.However, mere empirical observations are not satisfactory.These should be justified by plausible arguments.There are three convergence aspects, semantic, algebraic and topological, and this paper focuses on the algebraic aspect.Linear algebra is the basis for Linear Software Models, a rigorous theory of software systems composition from sub-systems, recently developed.Linear algebra, with added non-linearity, is also the basis for Deep Learning, a successful Artificial Intelligence domain.This work suggests and analyzes Deep Software Learning, i.e.Deep Learning specific to Software development problems.We then conjecture on deep reasons for Software-Knowledge convergence.

Modularity Matrices and their Laplacians enable finding software system modules by a rigorous algebraic procedure.However, Modularity Matrices have up to now focused mainly on structors as providers of functionals.This paper takes a broader view at the software system as a whole.The Software System Modularity Matrix, besides displaying provider relationships, also describes which structors consume functionals provided by other structors.This broader view improves software system design in two ways.First, consumer relationships set realistic expectations for consumer numbers and roles.Second, the Software System Modularity Matrix generates standard design criteria for interacting providers and consumers.This standard System matrix obeys linear independence of its constituent vectors, and block-diagonality of its recognizable modules.The novelty consists of modules being composed into a whole working Software System by means of a limited number of consumers playing the role of module connectors.Modules and their connectors are formally obtained by the same spectral method applied to the respective Laplacian, which obtained provider matrices.This is illustrated by case studies.

Software practices often evolved sets of efficient software design rules embodying together a kind of methodology.However, methodologies per se are no substitute for a rigorous software theory.Methodologies can live side by side with a software theory which explains and justifies the widely accepted wisdom of the field.This paper shows that Linear Software Models, an algebraic Software Theory together with its basis, the Conceptual Integrity principles, indeed explain the deeper contents of the so-called "four rules of simple design", which we concisely name as Agile-Design-Rules.These rules are a succinct expression of agile design methodologies that emerged from Extreme Programming (XP).Thus one obtains the best benefits from Software Theory and methodology co-existence: 1 st , the explained rules reinforce the Software Theory plausibility; 2 nd , the Software Theory selectively clarifies roles of the Agile-Design-Rules enabling quantitative calculations for their application in practice; 3 rd , co-existence leads to the idea of Design Tests as illustrated by case studies.

Large social Networks have marketing potential to spread information about interesting events to suitable audiences.However, huge network sizes and varieties of information available are obstacles to reach the desired goal.This paper investigates the hypothesis of computable Interestingness as a criterion to focus on suitable audiences for any given event.Interestingness is calculated by combining two functions: Relevance and Surprise.A generic software tool has been developed as an experimental testbed to interact with any social network.Its inputs are the event characterization and audience candidates for the given event.Two results validate this work's hypothesis: first, audience candidates who actually visited the event site, have on the average a bigger computed Interestingness than the rest of the population; second and most important, computed Interestingness better differentiates event site visitors, actually interested in the Event, from non-visitors, while Relevance alone, does not distinguish so-well between visitors and non-visitors.

We have recently shown that one can obtain the numbers and sizes of modules of a software system from the eigenvectors of its modularity matrix symmetrized and weighted by an affinity matrix. However such a weighting still demands a suitable definition of an affinity. This paper offers an alternative way to obtain the same results by means of the eigenvectors of a Laplacian matrix, directly obtained from the modularity matrix without the need of weighting. These two formalizations stand in a mutual isomorphism. We call it bipartite isomorphism since it is most straightforwardly shown by deriving the Laplacian from the modularity matrix and vice versa through the intermediate bipartite graph between two separate sets: the structors’ and the functionals’ sets. This isomorphism is also demonstrated through the equation defining the Laplacian in terms of the modularity matrix, or by the direct mapping of the respective matrices’ eigenvectors. Both matrices and the bipartite graph reflect one central idea: modules are connected components with high cohesion. The Laplacian matrix technique, of which the Fiedler vector is of central importance, is illustrated by case studies. An important claim of this paper is that, independently of the modularity matrix- and Laplacian matrix-specific properties, behind these two alternative matrices there is just one unified algebraic theory of software composition — the Linear Software Models — here concerning the application of the matrices’ eigenvectors to software modularity.

Conceptual Integrity has been claimed to be the essence of high-quality software system design.On the other hand, it has been a rather elusive attribute of software systems, challenging various attempts of a clear-cut characterization.This paper evolves in this direction by two means: first, by analysis and clarification of open issues in architecture and abstraction terms; second, by pointing out to a mathematical formulation in algebraic terms.This paper also serves as a broad introduction to discussions on "Conceptual Integrity of Software Systems".

Software Conceptual Integrity has been considered a cardinal concern for design and development of software systems.But, except for verbal descriptions of desiderata, there were no formal tools to guarantee that conceptual integrity is attained.This paper proposes an axiomatic algebraic approach, based upon the assumption that the software system in each level of the system hierarchy is represented by a Modularity Matrix.This representation enables to translate propriety, orthogonality and generality, usually taken as basic conceptual integrity principles, into formal algebraic criteria.The novelty is that one can finally make Conceptual Integrity quantitative calculations.The latter are illustrated by a case study.The paper also discusses the intimate relationship between software and knowledge, which emphasizes the importance of conceptual principles for software design. 1

Modularity Matrices for software systems can be put in block-diagonal form, where blocks are higher-level software modules, in a hierarchy of modules. But the exact module boundaries are often blurred by the uncertainty whether given matrix elements are module members or outliers. This paper provides an algorithm to determine module sizes. As a consequence the algorithm also decides which matrix elements are outliers. Matrix elements are weighted by their Affinity — an exponential function of the off-diagonality. The module size is given by the positive consecutive elements of the eigenvectors corresponding to the largest eigenvalues of this weighted symmetrized Modularity Matrix. By means of case studies, we illustrate the idea that outliers not only indicate the need for system redesign, but explicitly point out to problematic design spots. This work extends the applicability of linear algebra spectral methods to Modularity Matrices, at higher software abstraction levels than previously shown.

Modularity — the decoupling of software units — is essential for composition of real software systems from ready-made components. But for a long time one lacked a formal theory of modularity. Recently we have been developing Linear Software Models as rigorous theoretical modularity standards based upon plain Linear Algebra. By these models, decoupling means just linear independence, within a modularity matrix. This paper applies Linear Software Models to software systems, obtaining three consequences: (1) besides decoupling, various informal notions of software engineering, such as software modules, cohesion, and single responsibility, have for the first time a well-defined formal counterpart; (2) canonical building blocks like Software Design Patterns strictly obey the Linear Software Models; (3) larger software systems obey bordered Linear Models, allowing precise location and visualization of residual coupling. The latter consequences are demonstrated by case studies of software systems from the literature. The applicability of the Linear Software Models is quantitatively shown to scale well with system size, for the given case studies.