Abstract
This paper contributes to the computer ethics debate on software ownership protection by examining the ontological, methodological, and ethical problems related to property right infringement that should come prior to any legal discussion. The ontological problem consists in determining precisely what it is for a computer program to be a copy of another one, a largely neglected problem in computer ethics. The methodological problem is defined as the difficulty of deciding whether a given software system is a copy of another system. And the ethical problem corresponds to establishing when a copy constitutes, or does not constitute, a property right infringement. The ontological problem is solved on the logical analysis of abstract machines, and the latter are argued to be the appropriate level of abstraction for software at which the methodological and the ethical problems can be successfully addressed.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
See https://www.acm.org/code-of-ethics: “Developing new ideas, inventions, creative works, and computing artifacts creates value for society, and those who expend this effort should expect to gain value from their work. Computing professionals should therefore credit the creators of ideas, inventions, work, and artifacts, and respect copyrights, patents, trade secrets, license agreements, and other methods of protecting authors’ works. Both custom and the law recognize that some exceptions to a creator’s control of a work are necessary for the public good. Computing professionals should not unduly oppose reasonable uses of their intellectual works. Efforts to help others by contributing time and energy to projects that help society illustrate a positive aspect of this principle. Such efforts include free and open source software and work put into the public domain. Computing professionals should not claim private ownership of work that they or others have shared as public resources”.
These distinctions broadly refer to the Anglo-American legislations, but they can well be applied to most western legislations. Since the aim of this paper is to carry out a philosophical analysis of software systems that precedes the legal debate, reference to specific state legislations is avoided.
Articles of utility, non-creative expressions such as automatically generated texts, and public domain texts are usually out of the scope of copyright protection.
Just after the implementation of programmable computing machines, computer programs were developed and freely exchanged among programmers. As a result of the marketing of general purpose personal computers, software was sold and thus its ownership protected. In the USA, software was initially patented until 1976, when an amendment of the Copyright Act extended copyright protection to software code (see Koepsell 2003, ch. 5 for a historical overview of the copyright/patent legal debate for software).
Software development methods, such as the Waterfall, Spiral, or Agile models, focus, in principle, on three LoAs, namely the levels of requirements, design of algorithms and their relations, and implementation of algorithms in high-level language programs (Turner 2018). However, actual applications of those methods may not refer to all of those LoAs in practice; for instance, Agile methods often move from the elicitation of the software requirements directly to the implementation of a high-level program.
Samuelson et al. (1994) offer many concrete examples of actual US lawsuit cases of this sort.
Seemingly, this definition would exclude non-terminating procedures such as those characterizing reactive concurrent systems. It should be nonetheless noted that finite fragments of non-terminating procedures, and carrying out a specific computational task, do satisfy Newell’s starting definition of algorithms.
The general problem of determining whether a semantic property has a corresponding I/O procedure satisfying it is in general undecidable by Rice’s theorem (Rice 1953). The current formulation is decidable, as it compares with an existing algorithm.
For the translation of abstract machines into TSs, given a relation of equivalence over (initial and final) states, abstract machine M′ is called a correct refinement of abstract machine M if and only if for each execution of M′ there is an execution of M such that initial states of each are equivalent, there are reachable equivalent states, both executions terminate, their final states are the last pair of equivalent states, or both executions are infinite.
See Angius and Primiero 2018 for the corresponding formal treatment of the exact, inexact, and approximate copy relations.
We are assuming to perform a bitwise operation at the source code level only and not also at machine code level since, assuming correctness of implementations, any result of a bitwise operation at the high-level language instruction set level is inherited at the assembly/machine operation code level but not vice versa. Suppose a bitwise operation at the machine code level reveals that bit patterns are different. This does not imply that the source code is different. For instance, two copied and thereby identical high-level instruction sets result in different machine code operation sets in the case different compilers implement the source codes into two different architectures.
A path from an initial to a final state of a TS is given as a set of states and a set of transitions such that each state holds a transition relation with its successor state. For a more detailed and formal epistemological analysis of the practice of using abstract machines to improve software testing, see Angius 2013.
For the bisimulation relation TS ≡ TS′ to hold true, it is also required that TS and TS′ have the same branching structure.
Informally, the simulation quotient system of TS′ is the set of paths of TS′ that TS′ itself can simulate. Since every state transition system simulates itself, the simulation quotient system of TS′ is tantamount to the set of paths of TS′. If TS simulates at least one path in the simulation quotient system of TS′, then TS′ and TS have at least one path in common; that is, they prescribe at least one common behaviour.
Liveness and safety properties correspond to paths in the checked TSs, and copies share such properties in the case they simulate, among others, exactly those paths.
Intellectual property rights may also be defended following the “personality-based” argument contained in Hegel’s Philosophy of Right (Moore 2008 , 2001). Hegel claims that individuals possess property rights over products of physical or intellectual labour in that those products are externalizations of the author’s personality, feelings, and other features of her subjectivity. As long as the Anglo-American accounts of property rights dominate the software property right debate, the present discussion will focus on the consequentialist and deontologist arguments only.
Besides utilitarian arguments, free software promoters also advance “libertarian” and “communitarian” claims in support of their thesis. Proprietary software denies the liberty of modifying source code thereby impeding users to interact with programs in the way they wish. Mostly, proprietary regulations prevent from sharing the code with the community, harming those who are in need (Rapaport 2018).
It goes without saying that the intention, the algorithm as specification, and the algorithm as procedure LoAs, as being identified with cognitive processes and ideas, are not considered the outcome of human labour, though they may well be creative processes. Accordingly, their legal protection would violate condition (i) of the Lockean justification of intellectual property.
In the computer ethics debate, the rule utilitarian argument and the Lockean justification are considered two distinct moral frameworks wherein they argue in favour, or against, software property rights. This section is highlighting that, despite the fact that one is a consequentialist or a deontologist, she would find the algorithm as abstract machine level complying with her eligibility criteria for ownership protection.
For instance, the sorting algorithm as a specification defined in Section 3 can be implemented in varieties of algorithms as procedures and, in turn, in different algorithms as abstract machines. Besides the MergeSort procedure, abstract machines for the sorting specification can implement the binary tree sort algorithm as a procedure, or the tournament sort procedure, to give a couple of examples, which are nonetheless characterized by the same time complexity.
References
Ammann, P., & Offutt, J. (2016). Introduction to software testing. Cambridge: Cambridge University Press.
Angius, N. (2013). Model-based abductive reasoning in automated software testing. Logic Journal of IGPL, 21(6), 931–942.
Angius, N. (2014). The problem of justification of empirical hypotheses in software testing. Philosophy & Technology, 27(3), 423–439.
Angius, N., & Primiero, G. (2018). The logic of identity and copy for computational artefacts. Journal of Logic and Computation, 28(6), 1293–1322.
Baier, C., & Katoen, J. P. (2008). Principles of model checking. Cambridge: MIT press.
Barwise, J. (1989). Computers and Mathematics: Editorial Notes. In Notices of the A.M.S.
Breakey, H. (2010). Natural intellectual property rights and the public domain. The Modern Law Review, 73(2), 208–239.
Callahan, J., Schneider, F., & Easterbrook, F. (1996). Automated software testing using model checking. In J. C. Gregoire, G. J. Holzmann, & D. Peled (Eds.), Proceeding Spin Workshop (pp. 118–127). New Brunswick: Rutgers.
Carrara, M., & Soavi, M. (2010). Copies, replicas, and counterfeits of artworks and artefacts. The Monist, 93(3), 414–432.
Chisum, D. S. (1985). The patentability of algorithms. U. Pitt. L. Rev., 47, 959.
Dijkstra, E.W. (1970). Notes on structured programming. T. H.—Report 70-WSK-03.
Floridi, L. (2008). The method of levels of abstraction. Minds and Machines, 18(3), 303–329.
Floridi, L., Fresco, N., & Primiero, G. (2015). On malfunctioning software. Synthese (2015), 192, 1199–1220. https://doi.org/10.1007/s11229-014-0610-3.
Fokkink, W. (2013). Introduction to process algebra. Berlin: Springer Science & Business Media.
Gordon, W. J. (1993). A property right in self-expression: equality and individualism in the natural law of intellectual property. The Yale Law Journal, 102(7), 1533–1609.
Gurevich, Y. (2012). What is an algorithm? SOFSEM, 2012, 31–42.
Hill, R. K. (2016). What an algorithm is. Philosophy & Technology, 29(1), 35–59.
Johnson, D. G. (2009). Computer ethics (4th ed.). London: Pearson.
Koepsell, D. R. (2003). The ontology of cyberspace: philosophy, law, and the future of intellectual property. Chicago: Open Court Publishing.
Locke, J. (1690). The second treatise of government. [Locke 1690 available online].
Mooers, C. N. (1975). Computer software and copyright. ACM Computing Surveys (CSUR), 7(1), 45–72.
Moon, K. (2015). Another nail in the coffin for non-literal software copyright infringement?. Journal of Intellectual Property Law & Practice, 10(12), 921-930.
Moore, A. D. (2001). Intellectual property and information control: philosophic foundations and contemporary issues. New Brunswick, NJ: Transaction Publishers.
Moore, A. D. (2008). Personality-based, rule-utilitarian, and Lockean justifications of intellectual property. In K. Himma & H. Tavani (Eds.), The handbook of information and computer ethics (pp. 105–129). Hoboken: John Wiley & Sons.
Moore, A. D., & Himma, K. (2018). Intellectual property. In E. N. Zalta (Ed.), The Stanford Encyclopedia of Philosophy (Winter 2018 Edition). https://plato.stanford.edu/entries/intellectual-property/. (retrieved May, 31, 2019). Accessed 31 May 2019
Moschovakis, Y. (2001). What is an algorithm? In B. Engquist & W. Schmid (Eds.), Mathematics unlimited -- 2001 and beyond (pp. 919–936). Berlin: Springer.
Newell, A. (1985). Response: the models are broken, the models are broken. U. Pitt. L. Rev., 47, 1023.
Nissenbaum, H. (1995). Should I copy my neighbor’s software. Computer ethics and social values (pp. 200–213). Upper Saddle River, NJ: Prentice Hall.
Primiero, G. (2016). Information in the philosophy of computer science. In L. Floridi (Ed.), The Routledge handbook in the philosophy of information (pp. 90–106). Abingdon: Routledge.
Rapaport, W. J. (2018). Philosophy of computer science. Draft, 2018, available at https://cse.buffalo.edu/~rapaport/Papers/phics.pdf. Accessed 31 May 2019
Rice, H. G. (1953). Classes of recursively enumerable sets and their decision problems. Transactions of the American Mathematical Society, 74(2), 358–366.
Samuelson, P. (1989). Why the look and feel of software user interfaces should not be protected by copyright law. Communications of the ACM, 32(5), 563–573.
Samuelson, P. (1990). Legally speaking: should program algorithms be patented? Communications of the ACM, 33(8), 23–27.
Samuelson, P. (2016). Functionality and expression in computer programs: refining the tests for software copyright infringement. Berkeley Tech. LJ, 31, 1215.
Samuelson, P., Davis, R., Kapor, M. D., & Reichman, J. H. (1994). Manifesto concerning the legal protection of computer programs. A. ColUM. l. reV., 94, 2308.
Shavell, S., & Van Ypersele, T. (2001). Rewards versus intellectual property rights. The Journal of Law and Economics, 44(2), 525–547.
Stallman, R. (1985). The GNU manifesto.
Symons, J., & Horner, J. (2014). Software intensive science. Philosophy and Technology, 27(3), 461–477.
Turner, R. (2018). Computational artifacts: towards a philosophy of computer science. Berlin: Springer.
Vardi, M. Y. (2012). What is an algorithm. Communications of the ACM, 55(3), 5.
Acknowledgments
We are very grateful to Guglielmo Tamburrini for the helpful comments on an earlier version of this paper. We are also thankful to the two anonymous reviewers who provided productive remarks allowing us to better argue our theses.
Funding
Giuseppe Primiero was partially supported by the Project PROGRAMme ANR-17-CE38-0003-01.
Author information
Authors and Affiliations
Corresponding author
Additional information
Publisher’s Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Rights and permissions
About this article
Cite this article
Angius, N., Primiero, G. Infringing Software Property Rights: Ontological, Methodological, and Ethical Questions. Philos. Technol. 33, 283–308 (2020). https://doi.org/10.1007/s13347-019-00358-7
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s13347-019-00358-7