Nicola Angius

This paper introduces the Global Philosophy symposium on Giuseppe Primiero's book On the Foundations of Computing (2020). The collection gathers commentaries and responses of the author with the aim of engaging with some open questions in the philosophy of computer science. Firstly, this paper introduces the central themes addressed in Primiero's book; secondly, it highlights some of the main critiques from commentators in order to, finally, pinpoint some conceptual challenges indicating future directions for the philosophy of computer science.

This paper sheds light on the shift that is taking place from the practice of 'coding', namely developing programs as conventional in the software community, to the practice of 'curing', an activity that has emerged in the last few years in Deep Learning (DL) and that amounts to curing the data regime to which a DL model is exposed during training. Initially, the curing paradigm is illustrated by means of a study-case on autonomous vehicles. Subsequently, the shift from coding to curing is analysed taking into consideration the epistemological notions, central in the philosophy of computer science, of function, implementation, and correctness. First, it is illustrated how, in the curing paradigm, the functions performed by the trained model depend much more on dataset curation rather than on the model algorithms which, in contrast with the coding paradigm, do not comply with requested specifications. Second, it is highlighted how DL models cannot be considered implementations according to any of the available definitions of implementation that follow an intentional theory of functions. Finally, it is argued that DL models cannot be evaluated in terms of their correctness but rather in their experimental computational validity.

This paper shows how safety and liveness properties are not necessarily preserved by different kinds of copies of computational artefacts and proposes procedures to preserve them that are consistent with ethical analyses on software property rights infringement. Safety and liveness are second-order properties that are crucial in the definition of the formal ontology of computational artefacts. Software copies are analysed at the level of their formal models as exact, inexact, and approximate copies, according to the taxonomy in (Angius and Primiero, 2018). First, it is explained how exact copies are the only kind of copies that preserve safety and liveness properties, and how inexact and approximate copies do not necessarily preserve them. Secondly, two model checking algorithms are proposed to verify whether inexact and approximate copies actually preserve safety and liveness properties. Essential properties of termination, correctness, and complexity are proved for these algorithms. Finally, contraction and expansion algorithmic operations are defined, allowing for the automatic design of safety-and liveness-preserving approximate copies. As a conclusion, the relevance of the present logical analysis for the ongoing debates in miscomputation and computer ethics is highlighted.

The philosophy of computer science is concerned with the ontological and methodological issues arising from within the academic discipline of computer science, and from the practice of software development and its commercial and industrial deployment. More specifically, the philosophy of computer science considers the ontology and epistemology of computational systems, focusing on problems associated with their specification, programming, implementation, verification and testing. The complex nature of computer programs ensures that many of the conceptual questions raised by the philosophy of computer science have related ones in the philosophy of mathematics, the philosophy of empirical sciences, and the philosophy of technology. We shall provide an analysis of such topics that reflects the layered nature of the ontology of computational systems in Sections 1-5; we then discuss topics involved in their methodology in Sections 6-8.

Essential traits of model checking, a prominent formal method utilized in computer science to predict future behaviours of software systems, are examined here in the framework of the modelbased paradigm of scientific reasoning. Models that model checking techniques enable one to develop are shown to satisfy logical requirements expressed by the set-theoretic view of scientific models. It is highlighted how model checking algorithms are able to isolate law-like generalizations holding in the model under given ceteris paribus conditions and concerning software executions. Furthermore, abstraction methodologies utilized in model checking to decrease the state space of complex models are taken to be instantiations of the general process known as Aristotelian abstraction characterizing empirical modelling. Finally, the methodological interest of the model-checking techniques is emphasized in connection with the debate concerning the epistemological status of computer science. 1. Software...

This paper provides a review of Raymond Turner's book ​ Computational Artifacts. Towards a Philosophy of Computer Science​. Focus is made on the definition of program correctness as the twofold problem of evaluating whether ​ both the symbolic program ​ and the physical implementation satisfy a set of specifications. The review stresses how these are not two separate problems. First, it is highlighted how formal proofs of correctness need to rely on the analysis of physical computational processes. Secondly, it is underlined how software testing requires considering the formal relations holding between the specifications and the symbolic program. Such a mutual dependency between formal and empirical program verification methods is finally shown to ​ influence the debate on the epistemological status of computer science.

The Epistemology Of Computer Simulation (EOCS) has developed as an epistemological and methodological analysis of simulative sciences using quantitative computational models to represent and predict empirical phenomena of interest. In this paper, Executable Cell Biology (ECB) and Agent-Based Modelling (ABM) are examined to show how one may take advantage of qualitative computational models to evaluate reacha-bility properties of reactive systems. In contrast to the thesis, advanced by EOCS, that computational models are not adequate representations of the simulated empirical systems, it is shown how the representational adequacy of qualitative models is essential to evaluate reachability properties. Justification theory, if not playing an essential role in EOCS, is exhibited to be involved in the process of advancing and corroborating model-based hypotheses about empirical systems in ECB and ABM. Finally , the practice of evaluating model-based hypothesis by testing the simulated systems is shown to constitute an argument in favour of the thesis that computer simulations in ECB and ABM can be put on a par with scientific experiments.

This paper constitutes a first attempt at constructing semantic theories
over institutions and examining the logical relations holding between different such
theories. Our results show that this approach can be very useful for theoretical computer
science (and may also contribute to the current philosophical debate regarding
the semantic and the syntactic presentation of scientific theories). First we provide
a definition of semantic theories in the institution theory framework - in terms of a
set of models satisfying a given set of sentences - using the language-independent
satisfaction relation characterizing institutions (Definition 3). Then we give a proof
of the logical equivalence holding between the syntactic and the semantic presentation
of a theory, based on the Galois connection holding between sentences and
models (Theorem 1).We also show how to integrate and combine semantic theories
using colimits (Theorem 2). Finally we establish when the output of a model-based
software verification method applied to a semantic theory over an institution also
holds for a semantic theory defined over a different institution (Theorem 3).

The philosophy of computer science is concerned with those ontological, methodological, and ethical issues that arise from within the academic discipline of computer science as well as from the practice of software development. Thus, the philosophy of computer science shares the same philosophical goals as the philosophy of mathematics and the many subfields of the philosophy of science, such as the philosophy of biology or the philosophy of the social sciences. The philosophy of computer science also considers the analysis of computational artifacts, that is, human-made computing systems, and it focuses on methods involved in the design, specification, programming, verification, implementation, and testing of those systems. The abstract nature of computer programs and the resulting complexity of implemented artifacts, coupled with the technological ambitions of computer science, ensures that many of the conceptual questions of the philosophy of computer science have analogues in the philosophy of mathematics, the philosophy of empirical sciences, and the philosophy of technology. Other issues characterize the philosophy of computer science only. We shall concentrate on three tightly related groups of topics that form the spine of the subject. First we discuss topics related to the ontological analysis of computational artifacts, in Sections 1-5 below. Second, we discuss topics involved in the methodology and epistemology of software development, in Sections 6-9 below. Third, we discuss ethical issues arising from computer science practice, in Section 10 below. Applications of computer science are briefly considered in section 11.

The application of formal methods to the examination of reactive programs simulating cell systems’ behaviours in current computational biology is taken to shed new light on the simulative approaches in Artificial Intelligence and Artificial Life. First, it is underlined how reactive programs simulating many cell systems’ behaviours are more profitably examined by means of executable models of the simulating program’s executions. Those models turn out to be representations of both the simulating reactive program and of the simulated cell system. Secondly, it is highlighted how discovery processes of significant regular behaviours of the simulated system are carried out performing algorithmic verifications on the formal model representing the biological phenomena of interest. Finally, a distinctive methodological trait of current computational biology is recognized in that the advanced model-based hypotheses are not corroborated or falsified by testing the simulative program, which is not even encoded, but rather by performing wet experiments aiming at the observation of behaviours corresponding to paths in the model either satisfying or violating the hypotheses under evaluation.

This commentary on John Symons’ and Jack Horner’s paper, besides sharing its main argument, challenges the authors’ statement that there is no effective method to evaluate software intensive systems as a distinguishing feature of software intensive science. It is underlined here how analogous methodological limitations characterise the evaluations of empirical systems in non-software intensive sciences. The authors’ claim that formal methods establish the correctness of computational models rather than of the represented program is here compared with the empirical adequacy problem typifying the model-based reasoning approach in physics. And the remark that testing all the paths of a software intensive system is unfeasible is related to the enumerative induction problem in the justification of empirical law-like hypotheses in non-software intensive sciences.

This paper takes part in the methodological debate concerning the nature and the justification of hypotheses about computational systems in software engineering by providing an epistemological analysis of Software Testing, the practice of observing programs’ executions to examine whether they fulfil software requirements. Property specifications articulating such requirements are shown to involve falsifiable hypotheses about software systems that are evaluated by means of tests which are likely to falsify those hypotheses. Software Reliability metrics, used to measure the growth of probability that given failures will occur at specified times as new executions are observed, is shown to involve a Bayesian confirmation of falsifiable hypotheses on programs. Coverage criteria, used to select those input values with which the system under test is to be launched, are understood as theory-laden principles guiding software tests, here compared to scientific experiments. Redundant computations, fault seeding models, and formal methods used in software engineering to evaluate test results are taken to be instantiations of some epistemological strategies used in scientific experiments to distinguish between valid and non-valid experimental outcomes. The final part of the paper explores the problem, advanced in the context of the philosophy of technology, of defining the epistemological status of software engineering by conceiving it as a scientific attested technology.

Automated Software Testing (AST) using Model Checking is in this article epistemologically analysed in order to argue in favour of a model-based reasoning paradigm in computer science. Preliminarily, it is shown how both deductive and inductive reasoning are insufficient to determine whether a given piece of software is correct with respect to specified behavioural properties. Models algorithmically checked in Model Checking to select executions to be observed in Software Testing are acknowledged as analogical models which establish isomorphic relations with the target system's data set. Analogical models developed in AST are presented as abductive models providing hypothetical explanations to observed executions. The model assumption—algorithmic check—software testing process is understood as the abduction—deduction—induction process defining the selective abduction and turned to isolate a set of model-based hypotheses concerning the target system behaviours. A manipulative abduction process is finally recognized in the practice of adapting, abstracting and refining models that do not provide successful predictions.

Questions concerning the epistemological status of computer science are, in this paper, answered from the point of view of the formal verification framework. State space reduction techniques adopted to simplify computational models in model checking are analysed in terms of Aristotelian abstractions and Galilean idealizations characterizing the inquiry of empirical systems. Methodological considerations drawn here are employed to argue in favour of the scientific understanding of computer science as a discipline. Specifically, reduced models gained by Data Abstraction are acknowledged as Aristotelian abstractions that include only data which are sufficient to examine the interested executions. The present study highlights how the need to maximize incompatible properties is at the basis of both Abstraction Refinement, the process of generating a cascade of computational models to achieve a balance between simplicity and informativeness, and the Multiple Model Idealization approach in biology. Finally, fairness constraints, imposed to computational models to allow fair behaviours only, are defined as ceteris paribus conditions under which temporal formulas, formalizing software requirements, acquire the status of law-like statements about the software systems executions.

Essential traits of model checking, a prominent formal method utilized in computer science to predict future behaviours of software systems, are examined here in the framework of the model-based paradigm of scientific reasoning. Models that model checking techniques enable one to develop are shown to satisfy logical requirements expressed by the set-theoretic view of scientific models. It is highlighted how model checking algorithms are able to isolate law-like generalizations holding in the model under given ceteris paribus conditions and concerning software executions. Further-more, abstraction methodologies utilized in model checking to de-crease the state space of complex models are taken to be instantia-tions of the general process known as Aristotelian abstraction char-acterizing empirical modelling. Finally, the methodological interest of the model-checking techniques is emphasized in connection with the debate concerning the epistemological status of computer science.

This paper offers a review of Giuseppe Primero’s (2020) book “On the foundations of computing”. Mathematical, engineering, and experimental foundations of the science of computing are examined under the light of the notions of formal, physical, and experimental computational validity provided by the author. It is challenged the thesis that experimental computational validity can be defined only for the algorithmic method and not for the software development process. The notions of computational hypothesis and computational experiment provided by Primiero (2020) are extended to the case of software development. Finally, it is highlighted how the hypothetical-deductive method is involved in the practice of using models to corroborate computational hypotheses in software testing. As a concluding remark, it is underlined how defining experimental computational validity in the context of software development offers a sound experimental foundation to the science of computing.