Philosophy & Technology

, Volume 26, Issue 3, pp 253–272 | Cite as

Miscomputation

Research Article
First Online:
Received:
Accepted:

Abstract

The phenomenon of digital computation is explained (often differently) in computer science, computer engineering and more broadly in cognitive science. Although the semantics and implications of malfunctions have received attention in the philosophy of biology and philosophy of technology, errors in computational systems remain of interest only to computer science. Miscomputation has not gotten the philosophical attention it deserves. Our paper fills this gap by offering a taxonomy of miscomputations. This taxonomy is underpinned by a conceptual analysis of the design and implementation of conventional computational systems at various levels of abstraction. It shows that ‘malfunction’ as it is typically used in the philosophy of artefacts only represents one type of miscomputation.

Keywords

Computer science Specification Program Errors Malfunction Design Implementation Physical computation 
This is a preview of subscription content, log in to check access.

Notes

Acknowledgments

We thank Marty Wolf for a useful discussion on miscomputation in physical systems. We also thank the two referees for their constructive comments and suggestions that have improved the paper. This research was conducted while Giuseppe Primiero was a Post-Doctoral Fellow of the Research Foundation Flanders (FWO) at the Centre for Logic and Philosophy of Science, Ghent University, Belgium. He gratefully acknowledges the financial support.

References

  1. Bjørner, D., & Henson, M. C. (2008). Logics of specification languages. Berlin: Springer.CrossRefGoogle Scholar
  2. Black, P. E., Hall, K. M., Jones, M. D., Larson, T. N., & Windley, P. J. (1996). A brief introduction to formal methods (pp. 377–380). IEEE. doi: 10.1109/CICC.1996.510579.
  3. Buhr, P. A., Harji, A., & Russell Mok, W. Y. (2002). Exception handling. Advances in Computers, 56, 245–303. Elsevier.CrossRefGoogle Scholar
  4. Campione, M., Walrath, K., & Huml, A. (2001). The Java tutorial: short course on the basics. Boston: Addison-Wesley.Google Scholar
  5. Curry, H. B. (1934). Functionality in Combinatory Logic. Proceedings of the National Academy of Sciences of the United States of America, 20(11), 584–590.CrossRefGoogle Scholar
  6. Curry, Haskell B., Feys, R., & Craig, W. (1958). Combinatory logic. Vol. 1. Amsterdam: North-Holland.Google Scholar
  7. Dale, N. B., & Weems, C. (2005). Programming and problem solving with C++. Boston: Jones and Bartlett Publishers.Google Scholar
  8. Davie, A. J. T. (1992). An introduction to functional programming systems using Haskell. Cambridge: Cambridge University Press.Google Scholar
  9. Dooley, J. (2011). Software development and professional practice. New York: Apress. doi: 10.1007/978-1-4302-3802-7.
  10. Feldman, M. B., & Koffman, E. B. (1999). Ada 95: problem solving and program design. Reading: Addison-Wesley.Google Scholar
  11. Franssen, M. (2006). The normativity of artefacts. Studies in History and Philosophy of Science Part A, 37(1), 42–57. doi: 10.1016/j.shpsa.2005.12.006.CrossRefGoogle Scholar
  12. Fresco, N. (2012). Concrete digital computation: competing accounts and its role in cognitive science. University of New South Wales, Sydney, Australia. Retrieved from http://handle.unsw.edu.au/1959.4/52578.
  13. Hari, S. K. S., Konda, V. V. R., Kamakoti, V., Vedula, V. M., & Maneperambil, K. S. (2008). Automatic constraint based test generation for behavioral HDL Models. IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 16(4), 408–421. doi: 10.1109/TVLSI.2008.917424.CrossRefGoogle Scholar
  14. Hempel, C. G. (1965). Aspects of scientific explanation: and other essays in the philosophy of science. New York: Free Press.Google Scholar
  15. Hopcroft, J. E., Motwani, R., & Ullman, J. D. (2001). Introduction to automata theory, languages, and computation. Boston: Addison-Wesley.Google Scholar
  16. Houkes, W., & Vermaas, P. E. (2010). Technical functions: on the use and design of artefacts. Dordrecht: Springer.CrossRefGoogle Scholar
  17. Howard, W. A. (1980). The formulae-as-types notion of construction. In J. P. Seldin & J. R. Hindley (Eds.), (pp (pp. 479–490). London: Academic.Google Scholar
  18. IEEE Computer Society. (2005). IEEE Standard for Property Specification Language (PSL). IEEE Std 1850-2005, 0_1–143. doi: 10.1109/IEEESTD.2005.97780.
  19. IEEE Computer Society. (2009). IEEE Standard for Information Technology—Systems Design—Software Design Descriptions—Redline.Google Scholar
  20. IEEE Computer Society. (1998). IEEE recommended practice for software requirements specifications. New York: Institute of Electrical and Electronics Engineers.Google Scholar
  21. Intel. (2004). FDIV replacement program: statistical analysis of floating point flaw. Available from http://www.intel.com/support/processors/pentium/sb/CS-013005.htm. Accessed 28 January 2012.
  22. Jespersen, B., & Carrara, M. (2011). Two conceptions of technical malfunction. Theoria, 77(2), 117–138. doi: 10.1111/j.1755-2567.2010.01092.x.CrossRefGoogle Scholar
  23. Kitcher, P. (1989). Explanatory unification and the causal structure of the world. In P. Kitcher & W. C. Salmon (Eds.), Scientific explanation (pp. 410–505). Minneapolis: University of Minnesota Press.Google Scholar
  24. Lam, W. K. C. (2005). Hardware design verification: simulation and formal method-based approaches. Upper Saddle River: Prentice-Hall.Google Scholar
  25. Lee, P. A., & Anderson, T. (1990). Fault tolerance, principles and practice. Wien: Springer.CrossRefGoogle Scholar
  26. Mahner, M., & Bunge, M. (1997). Foundations of biophilosophy. Berlin: Springer.CrossRefGoogle Scholar
  27. May, M., Alles, M., & Wehn, N. (2008). A case study in reliability-aware design: a resilient LDPC code decoder (pp. 456–461). IEEE. doi: 10.1109/DATE.2008.4484723.
  28. Meyer, B. (1985). On Formalism in Specifications. IEEE Software, 2(1), 6–26. doi: 10.1109/MS.1985.229776.CrossRefGoogle Scholar
  29. Millikan, R. G. (1989). In defense of proper functions. Philosophy of Science, 56(2), 288–302.CrossRefGoogle Scholar
  30. MSDN. (2012). Hardware Errors and Error Sources. Microsoft. Available from http://msdn.microsoft.com/en-us/library/windows/hardware/ff559382%28v=vs.85%29.aspx.
  31. Neander, K. (1995). Misrepresenting & malfunctioning. Philosophical Studies, 79(2), 109–141. doi: 10.1007/BF00989706.CrossRefGoogle Scholar
  32. Palnitkar, S. (2003). Verilog HDL: a guide to digital design and synthesis. Upper Saddle River: SunSoft Press.Google Scholar
  33. Perlman, M. (2010). Traits have evolved to function the way they do because of a past advantage. In F. J. Ayala & R. Arp (Eds.), Contemporary debates in philosophy of biology (pp. 53–72). Malden: Wiley-Blackwell.Google Scholar
  34. Piccinini, G. (2007). Computing mechanisms. Philosophy of Science, 74(4), 501–526. doi: 10.1086/522851.CrossRefGoogle Scholar
  35. Primiero, G. (2013). A Taxonomy of Errors for Information Systems. Minds and Machines. doi: 10.1007/s11023-013-9307-5.
  36. Purdum, J. J. (2012). Beginning object oriented programming with C#. Hoboken: Wiley.Google Scholar
  37. Shelly, G. B., Cashman, T. J., Starks, J., & Mick, M. L. (2006). Java programming: comprehensive concepts and techniques. Boston: Thomson/Course Technology.Google Scholar
  38. Smith, B. C. (1996). Limits of correctness in computers. In R. Kling (Ed.), Computerization and controversy: value conflicts and social choices. San Diego: Academic.Google Scholar
  39. Sørensen, M. H., & Urzyczyn, P. (2006). Lectures on the Curry–Howard isomorphism. Amsterdam]: Elsevier.Google Scholar
  40. Strevens, M. (2008). Depth: an account of scientific explanation. Cambridge: Harvard University Press.Google Scholar
  41. Turing, A. M. (1950). Computing machinery and intelligence. Mind, 59(236), 433–460.CrossRefGoogle Scholar
  42. Turner, R. (2011). Specification. Minds and Machines, 21(2), 135–152. doi: 10.1007/s11023-011-9239-x.CrossRefGoogle Scholar
  43. Turner, R. (2013). Programming languages as technical artifacts. Philosophy & Technology. doi: 10.1007/s13347-012-0098-z.Google Scholar
  44. Turner, R., & Eden, A. (2011). The Philosophy of Computer Science. In E. N. Zalta (Ed.), The Stanford Encyclopedia of Philosophy (Winter 2011.). Available from http://plato.stanford.edu/archives/win2011/entries/computer-science/.
  45. Williams, T. J., Schaffer, E. J., & Rohr, A. (2003). Redundant and voting systems. In Instrument engineers’ handbook. Boca Raton: CRC Press.Google Scholar
  46. Woodward, J. (2005). Making things happen: a theory of causal explanation. New York: Oxford University Press.Google Scholar

Copyright information

© Springer Science+Business Media Dordrecht 2013

Authors and Affiliations

  1. 1.School of Humanities, UNSWSydneyAustralia
  2. 2.Department of Computer ScienceMiddlesex UniversityLondonUK

Personalised recommendations