Search

One staple of living in our information society is having access to the web. Web-connected devices interpret our queries and retrieve information from the web in response. Today's web devices even purport to answer our queries directly without requiring us to comb through search results in order to find the information we want. How do we know whether a web device is trustworthy? One way to know is to learn why the device is trustworthy by inspecting its inner workings (Lehrer The Monist, 78(2), 156-170 1995 (See CR4); Humphreys 2004 (See CR2), Episteme, 6(2), 221-229 2009 (See CR3)). But ordinary users of web devices cannot inspect their inner workings because of their scale, complexity, and the corporate secrecy which enshrouds both the procedures by which the devices operate and the companies that make them (Pasquale 2015 (See CR6)). Further piling on this predicament, authors have criticized web technology on the grounds that the invisibility of the web devices' inner workings prevents users from critically assessing the procedures that produce a given output, in some cases, barring users from fulfilling their epistemic responsibilities (Simon Ethics and Information Technology, 12(4), 343-355 2010 (See CR7); Miller and Record Episteme, 10(2), 117-134 2013 (See CR5)). I consider four broad kinds of reasons which we can acquire without inspecting the inner workings of black-boxed technology: individual understanding, expert testimony, testing through experience, and social vetting; and show how each is a viable method of appraising black-boxed technology. By deploying these methods, we can remain responsible inquirers while nonetheless benefitting from today's epistemic resources on the web., Author(s): E. S. Dahl [sup.1] Author Affiliations: (Aff1) 0000 0004 0456 0419, grid.182981.b, Reed College, , Box 220, 3203 SE Woodstock Blvd, 97202, Portland, OR, USA One staple of living [...]

Floating-point computations are quickly finding their way in the design of safety- and mission-critical systems, despite the fact that designing floating-point algorithms is significantly more difficult than designing integer algorithms. [...]

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 the 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 scientifically attested technology. Keywords Philosophy of computer science * Software testing * Falsificationism * Bayesian epistemology * Scientific experiments, 1 Introduction Software development processes are constrained by program requirements the final artefact is wanted to fulfil. Such requirements articulate specific behaviours the system asked to assume and are expressed [...]

The primary role of testers is to verify and validate the software produced by developers to ensure its quality. Testing is designed to catch problems in the software and report them for correction, so it is a conflict-laden, confrontational, and judgmental process. This 'audit' role of testing is inherently adversarial, ensuring the development of components of interpersonal conflict judgments between developers and testers. Prior research indicates that such conflict is likely to be negatively associated with software quality and job satisfaction, producing negative judgments about the artifact production process and about the job itself. This study addresses the question: How do judgments of conflict between developers and testers impact the software development process? The authors develop and empirically test a research model which proposes that the conflict judgment targets of both the tasks and the persons who perform them will have direct impact on both software quality and job satisfaction judgments. Results of testing this model indicate that interpersonal judgments arising from conflict, as well as judgments made by testers and developers about the conflict targets of tasks and persons negatively influence subsequent software quality and job satisfaction judgments. Implications for theory and practice are discussed. Keywords: Interpersonal Conflict Judgments, Job Satisfaction, Person Target Judgments, Software Development and Testing, Software Quality, Task Target Judgments, INTRODUCTION One of the most important role interactions in software development is between developers (i.e., systems analysts, designers, and programmers) and testers (Cohen et al., 2004; Robey et al., 2001). [...]

Traditional static type systems are effective for verifying basic interface specifications. Dynamically checked contracts support more precise specifications, but these are not checked until runtime, resulting in incomplete detection of defects. Hybrid type checking is a synthesis of these two approaches that enforces precise interface specifications, via static analysis where possible, but also via dynamic checks where necessary. This article explores the key ideas and implications of hybrid type checking, in the context of the [lambda]-calculus extended with contract types, that is, with dependent function types and with arbitrary refinements of base types. Categories and Subject Descriptors: D.3.1 [Programming Languages]: Formal Definitions and Theory General Terms: Languages, Theory, Verification Additional Key Words and Phrases: Type systems, contracts, static checking, dynamic checking DOI = 10.1145/1667048.1667051