ArticlePDF Available

Abstract and Figures

On the basis of an earlier contribution to the philosophy of computer science by Amnon Eden, this essay discusses to what extent Eden’s ‘paradigms’ of computer science can be transferred or applied to software engineering. This discussion implies an analysis of how software engineering and computer science are related to each other. The essay concludes that software engineering can neither be fully subsumed by computer science, nor vice versa. Consequently, also the philosophies of computer science and software engineering—though related to each other—are not identical branches of a general philosophy of science. This also implies that not all of Eden’s earlier arguments can be directly mapped from the domain of computer science into the domain of software science. After the discussion of this main topic, the essay also points to some further problems and open issues for future studies in the philosophy of software science and engineering.
Content may be subject to copyright.
Problems for a Philosophy of Software Engineering
Stefan Gruner
Received: 1 December 2009 / Accepted: 8 October 2010
ÓSpringer Science+Business Media B.V. 2011
Abstract On the basis of an earlier contribution to the philosophy of computer
science by Amnon Eden, this essay discusses to what extent Eden’s ‘paradigms’ of
computer science can be transferred or applied to software engineering. This dis-
cussion implies an analysis of how software engineering and computer science are
related to each other. The essay concludes that software engineering can neither be
fully subsumed by computer science, nor vice versa. Consequently, also the phi-
losophies of computer science and software engineering—though related to each
other—are not identical branches of a general philosophy of science. This also
implies that not all of Eden’s earlier arguments can be directly mapped from the
domain of computer science into the domain of software science. After the dis-
cussion of this main topic, the essay also points to some further problems and open
issues for future studies in the philosophy of software science and engineering.
Keywords Computer science Software engineering Paradigms
Introduction and Motivation
The call for philosophical meta theory of software science and engineering is partly
due to the success and partly due the problems, shortcomings and failures
experienced by this still rather young discipline so far. Had software engineering
had no success at all up to now, then it might probably have vanished already as
This essay is written in commemoration of the 100th birthdays of Konrad Zuse and Lothar Collatz (both
*1910) during the year 2010. Zuse contributed to the science of computing coming from the domain of
engineering, Collatz from the domain of mathematics.
S. Gruner (&)
Research Group for Software Science and Formal Methods, Department of Computer Science,
Universiteit van Pretoria, 0002 Pretoria, Republic of South Africa
e-mail: sg@cs.up.ac.za
123
Minds & Machines
DOI 10.1007/s11023-011-9234-2
rapidly as it had emerged. In this way it could have become at best a footnote in
future’s books on the history of science, but not a topic of this essay. For example,
the global social evolution induced by the internet and mobile telephony, which has
profoundly changed some social habits even in deepest Africa, would not have been
possible without the achievements of software engineering in its role as an ‘enabling
technology’. On the other hand, had software engineering been only successful and
nothing but successful until today, then we would most probably still indulge
complacently in the sunshine of our success and would not feel any necessity for
critical reflection and self-reflection. The notorious failure of the Ariane 5 space
flight #501 on the 4th of June 1996 is probably the most widely known example of
the dire consequences of software defects. As it is common knowledge today, the
‘causa proxima’ of that costly accident was a software defect, or, to be more precise:
a numeric type error after the device’s control software had been wrongly ported
from the hardware system of Ariane 4 to the slightly different hardware system of
Ariane 5. From such kind of suffering, philosophy emerges.
Philosophy of computer science (which is the general theme of this special issue
of this journal) deals predominantly with problems and questions around the nature
of computation as a process in time, the physicality or non-physicality of
information (Landauer 1961), or with the question whether or not computer science
belongs to the group of mathematical or natural sciences (Denning 2007). Thus the
question arises why an essay on the philosophy of software engineering should find
its place in a special issue on the philosophy of computer science? This could be
justified with the answer that software engineering is a sub-field of the field of
computer science, as some scholars would argue, or that software engineering is
based on computer science as its auxiliary science, as other scholars would argue.
The question, whether software engineering is a sub-field of computer science, or
whether computer science is only an auxiliary science to an independent field of
software engineering, is a science-philosophical question with relevance also to the
philosophy of computer science. Anyway—whatever answer to that question the
reader might prefer—we can state with a high degree of credibility that software
engineering has not yet been sufficiently taken into account in our attempts towards
a philosophical understanding of computer science. Though there already exist
several science-philosophical reflections by various authors on various topics in the
computer science context of software engineering—see, for example, the contri-
bution by Smith on the ontology of objects (Smith 1998) (which are particularly
relevant concepts in software engineering), science-philosophical reflections on the
topic of ‘agile’ software development (Northover et al. 2007), the latest work by
Kroeze on the notion of ontology in software engineering (Kroeze 2010), the works
by Fetzer on the philosophy of program verification (Fetzer 1988,1998) as well as
on the concept of models in computer science (Fetzer 1999)—the field of software
science and software engineering as a whole is surely not yet exhaustively explored
and philosophically reflected. For these reasons, this essay aims at making another
step into this direction.
This step shall be made by reviewing and discussing some recent issues in the
philosophy of software engineering, and, consequently, by pointing to some open
problems which deserve our attention in future studies. The essay as a whole is
S. Gruner
123
motivated by a recent verdict by Rombach and Seelisch: ‘‘up to now, a concise,
practicable theory of software engineering does not exist’’ (Rombach and Seelisch
2008). Indeed, most of the critical and meta-theoretic remarks about software
engineering have come from philosophically minded software scientists and
engineers within this discipline so far. Therefore we are still hoping for a more
interdisciplinary discourse, together with professional philosophers of science (also:
historians of science, sociologists of science, etc.), in this field.
In a recent article by Amnon Eden in this journal (Eden 2007) one can find an
interesting discussion of three different ‘paradigms’ of computer science, whereby
software engineering—the topic of this essay—was associated by Eden with the
‘technocratic’ one of those three paradigms.
1
For each of those three paradigms of
computer science, Eden had identified different philosophical foundations and
presuppositions in three philosophical areas, namely
ontology (i.e.: what exists),
epistemology (i.e.: what can be known), and
methodology (i.e.: how can knowledge be reached).
The argument in this essay mimics Eden’s argument structurally in the sense that
we will also identify and discuss three different ‘paradigms’ of software
engineering. This discussion will also entail some critique of Eden’s somewhat
too one-sided association of software engineering, as a whole, with the ‘technocratic
paradigm’ of computer science. Anyway, Eden (2007) will be the most important
point of reference in the discourse of this essay. Throughout this essay it is assumed
that the readers already have some basic understanding of software engineering as
an academic and industrial discipline; further explications can be found in the
standard literature.
Finally, after its central argument, this essay also suggests (in its outlook section)
some possibly promising themes for future studies in the philosophy of software
science and software engineering. Those further themes could not be discussed in
this essay any more, partly due to lack of page space and partly for the sake of
topical cohesion.
‘Paradigms’ and Quarrels About the Foundations of Sciences
As Eden had pointed out in Eden (2007) there are often deeper science-
philosophical issues behind the facades of obvious ‘paradigmatic’ differences. This
shall be shown also for the case of software engineering in the following parts of
this essay—though the now rather modish term ‘paradigm’ should not be used
inflationary, for it would otherwise lose its particularly important Kuhnian attributes
1
One of the anonymous reviewers of the pre-print draft of this article suggested that Eden would have
‘conjectured’’ the technocratic paradigm mainly for methodological reasons, so-to-say as an ideal
methodological entity without a strong basis in reality. However, Eden has recently confirmed (in private
communication) that he still believes that ‘‘the technocratic paradigm is not only live and kicking, but it
also has all but taken over computer science, at least at the level of funding and other forms of decision
making, which singularitly affects the direction that this field is taking’’ (18 Oct 2010, via eMail).
Problems for a Philosophy of Software Engineering
123
of historic dominance and systematic incommensurability, Masterman’s critique of
the lack of univocity of the term ‘paradigm’ (Masterman 1970) throughout Kuhn’s
writings notwithstanding.
Anyway, the science-philosophical issue behind a ‘paradigm’ is in many cases
something which the constructivists have called the ‘problem of origin’
2
, i.e., the
problem about how to establish the conceptual foundations of a particular science
consistently and without petitio principii. Even if one is not an ardent supporter of
the school of constructivism,
3
one has to credit the protagonists of that philosophical
school for their sincere enquiries in the context of the ‘problem of origin’.
Whilst the methodological constructivists approached this problem rather
pragmatically (i.e., by reference to action, thus somewhat similar to Heidegger’s
concepts of ‘world’
4
and ‘equipment’
5
), the problem of origin also has a rational
aspect which reveals itself in the words (terms, notions, concepts) that are
axiomatically used in the terminological system of a scientific theory but which are
essentially not explained by the theory itself to which they belong. Consequently,
such un-explained fundamental terms and notions can be taken as ‘doors’ through
which we can proceed from the restricted domain of a particular science into the
wider realm of philosophy. For a number of long-established sciences, the following
examples of ‘door concepts’ are well known to every student of philosophy:
In biology, ‘life’ is comprehensively described but not essentially explained in
its deeper nature.
6
In physics, ‘energy’ and ‘force’ remain two aptly described and quantifiable
meta-physical mysteries.
In stochastics and mathematical statistics, we quantify but do not essentially
clarify the imported idea of ‘probability’ or ‘likelihood’.
In formal logics, we use but do not deeply explain the notion of ‘truth’.
In jurisprudence, the notion of ‘law’ is based on the idea of justice, but an
ultimate definition of ‘justice’ cannot be given within the legal framework itself
(and history has indeed seen many examples of unjust laws).
In informatics (computer science) as well as in information theory (i.e., the
science about message transmissions via channels following the works by
Claude Shannon) we use the idea of ‘information’ but we cannot essentially
explain its deeper meaning within the theoretical framework of these sciences.
2
Anfangsproblem.
3
Hugo Dingler, Peter Janich, et al. Their methodological constructivism must not be confused with
epistemological constructivism (truth as social construct) and also not with Brouwer’s mathematical
constructivism, a.k.a. intuitionism (in which, amongst others, the classical tertium-non-datur axiom,
::AA, is not accepted).
4
Welt.
5
Zeug.
6
Unless, of course, we would be willing to amputate the semantics of ‘explanation’ deliberately and ad-
hoc to such a crippled extent that it becomes, by decree, equivalent to the semantics of ‘comprehensive
description’.
S. Gruner
123
In classical mathematics, a pre-understanding of the notion of ‘proof’ beyond
the symbolic operations is taken for granted.
In psychology, the concepts of ‘soul’ and ‘mind’ lead straight into one of the
oldest and most notorious problems of philosophical thought.
Historians and philosophers of science will notice easily that a ‘foundation
dispute’
7
—i.e., a methodological, meta-scientific issue as exemplified above—has a
tendency to emerge particularly at the ‘threshold’ of such a ‘door’ between a
particular science and general philosophy. In all those foundational disputes there
was ultimately a problem of metaphysics at stake: Shall metaphysics be
acknowledged and admitted at all, yes or no?—if yes, then how much of it?—
etc. The quarreling parties in most of those examples listed above were usually
some sorts of ‘positivists’, ‘empiricists’, ‘formalists’, ‘behaviourists’, ‘reduction-
ists’, ‘materialists’ (etc.) on the one side, versus some sorts of ‘platonists’, ‘holists’,
‘rationalists’, ‘idealists’ (etc.) on the opposite side. Take, for example, the notorious
debate about vitalism in meta biology and philosophy of nature (e.g., Hans Driesch),
or the flurry of modern truth-theories behind the scenes of socio-linguistics, textual
hermeneutics, and mathematical logics. Another illustrative example is the
foundation dispute of meta mathematics about the notion of ‘proof’, which lead
to Brouwer’s and Heyting’s intuitionism, to further progress in proof theory, etc.
For our field of informatics or computer science, empiricism versus rationalism
was discussed in Eden (2007). Whereas Eden has delivered a foundation analysis for
the domain of computer science, and thereby identified (or at least strongly
associated) software engineering as (or with) one particular ‘paradigm’ in (or of)
computer science (Eden 2007), this essay goes further to discuss different
philosophical ‘streams’ within software engineering itself (which Eden had still
treated more or less as one monolithic entity without mentioning any of its inner
frictions and factions). Some kind of foundation dispute in software engineering we
can observe very clearly in these days, namely the one between followers of the
human-centered ‘agile’ versus the followers process-centered ‘engineering’ meth-
odologies (Northover et al. 2008), or the ‘humanists’ versus the ‘formalists’. This
quarrel between ‘humanists’ and ‘formalists’ in software engineering is also
connected with the questions whether or not software engineering be a sub-science
of computer science, and—even more problematic—whether or not software
engineering is a ‘science’ at all. This problem, which was also a theme in Eden
(2007), will be further discussed in the remaining sections of this essay, in
continuation of some preliminary remarks which I had already made about this issue
in Gruner (2010).
However, before this discussion about the philosophical problems in software
engineering can continue, a few clarifying remarks need to be made about ‘what is?’
software engineering, on the basis of some clarification about ‘what is?’ software
itself.
7
Grundlagenstreit.
Problems for a Philosophy of Software Engineering
123
The Ontological Status of Software
Much truth has already been said and written about the ontological status of
computer programs or software as a non-material entity: see for example Olson
(1997) (especially for the domain of artificial life), Cleland (2001), Broy and
Rombach (2002), Eden (2007), Northover et al. (2008), and many others. To date,
and in those literature examples, there is still some ambiguity about the notions of
‘software’ and ‘computer programs’ which would deserve some further clarification
(i.e.: are ‘software’ and ‘computer programs’ extensionally equivalent concepts, or
are these concepts in some unidirectional inclusion relation with each other?), but
this question is not the main question of this essay.
For the understanding of the remainder of this essay it is sufficient to grasp the
immaterial nature of software in terms of this often told anecdote from the early
days of computing: There was a computer scientist traveling by ship to some
conference overseas, and the quartermaster of the vessel complained that the
‘software’ in the travelling scientist’s luggage, full of computer-readable punch
cards, was ‘‘too heavy’’. Answered the scientist to the ship’s quartermaster: ‘‘My
software weighs nothing! Do you see the holes in these punch cards? These holes
are the software!’
For the sake of argument in this essay (notwithstanding the literature references
on the ontological status of software as mentioned above) let us first of all
understand ‘software’ as text—however not the paper (or whatever material
substrate) on which the text is written. Like a poem, software has thus also aesthetic
qualities (which are often forgotten in the literature on software ontology), such as
form (even beauty in its form), legibility, etc. What distinguishes a module of
software from a poem is its interpretability and executability by some kind of
computing machinery: unlike a poem, software can ‘tell’ a computer ‘what to do’.
This feature of software reminds us, for example, of a baking recipe, which is also
text, however text in such a way that it can tell a baker in the bakery how to bake a
cake. Thus, in this very broad sense of the term, even a baker’s recipe for cake
baking could be regarded as ‘software’, whereby the specific differences between
this kind of ‘software’ and actually executable computer programs are mainly found
in the degree of detail and precision as far as the algorithmic description (or
prescription) of the executable computational steps are concerned (Cleland 2001).
For comparison see also Eden (2007) wherein we can find further terminological
distinctions of ‘program script’, ‘program process’, etc.
By the way, my classification of software code as ‘text’ should not be mistaken as
just a fashionable ‘postmodernist’ hermeneutical gimmick. This classification has its
justification in the very construction principle of the classical von-Neumann/Zuse
hardware architecture itself, in which both ‘instructions’ and ‘data’ are stored as bit
patterns—i.e.: ‘text’—indistinguishable from each other in the same type of storage
(RAM). Whether a bit pattern in some RAM cell cis interpreted as ‘instruction’ or
as ‘data’ depends mainly on the operations of the von-Neumann/Zuse machine at
runtime: see the ‘technocratic ontology’ of Eden (2007) for comparison.
Anyway, on the basis of the simple notion of ‘software’ as sketched above
(which is sufficient for the understanding of the remainder of this essay) it is fair to
S. Gruner
123
say that ‘software engineering’ is both the theory (science) of ‘grasping’ software,
as well as the practice (industry) of ‘making’ it in the best possible way. Thereby the
qualifier ‘best possible’ refers both to the quality of the production method (process)
and to the quality of the software as deliverable outcome (product) of that
production process. For clarification in terms of the bakery analogy of above, note
that the software engineer is not the analogon of the baker, and the software is not
the analogon of the cake. Rather: the software engineer is like somebody who
creates cake recipes for the baker, such that the baker (i.e., the computer) can bake
cake (i.e., computation output, calculation results) on the basis of a given recipe.
This simple analogy is all we need to keep in mind about software and software
engineering for understanding the subsequent sections of this essay. Whether or not
such a textual software recipe corresponds to a pre-existing ‘form’ or ‘idea’ in a
Platonic realm of super-reality—in other words: whether software recipes, in their
role as technical problem solutions, are ‘discovered’ or ‘invented’—is not a question
for this essay.
Software Engineering Between Rationalism and Empiricism
Ten years after the software engineer Gregor Snelting had sharply attacked
especially the academic (not so much the industrial) branch of software engineering
for an alleged attitude of ‘Feyerabendianism’ (Snelting 1998), by which he referred
to a flood of out-of-the-blue-sky concepts and rather unsound proposal publications,
the computer scientists and software engineers Rombach and Seelisch have
continued this dispute with their statement that ‘‘software engineering today, seen as
a practically highly relevant engineering discipline, is not mature enough’’
(Rombach and Seelisch 2008). This immaturity entails that most of the results
from scientific or academic software engineering research are currently not finding
their way into the industrial or commercial software engineering practice, such that
the knowledge gap between software engineering research and practice is widening
(Rombach and Seelisch 2008). Rombach and Seelisch further argued that this gap
between theory and practice is due to ‘‘a tremendous lack of empirical evidence
regarding the benefits and limitations of new software engineering methods and
tools on both sides’’ (Rombach and Seelisch 2008).
These practical problem statements lead consequently to the more science-
philosophical questions about the status of software engineering as an empirical
discipline—yes or no, and, if yes, to what extent: ‘‘The major claim of this work is
that typical shortcomings in the practical work of software engineers as we witness
them today result from missing or unacknowledged empirical facts. Discovering the
facts by empirical studies is the only way to gain insights in how software
development projects should be run best, i.e., insights in the discipline of software
engineering’’ (Rombach and Seelisch 2008). In that short paragraph one can already
detect two relevant science-philosophical problems (which Rombach and Seelisch
did not explicitly mention), namely:
Problems for a Philosophy of Software Engineering
123
How to bridge the category gap from ontology (‘‘discovering facts’’) to
deontology (‘‘how projects should be run best’’) without committing the
notorious naturalist fallacy?
What types of investigations may be methodologically admitted as ‘empirical
studies’ if software engineering at large does not (and cannot) happen in the
closed environment of a well-controlled physics laboratory? See for comparison
(Tichy 2007) presenting a classification of various empirical methods in
software engineering.
Rombach and Seelisch further identified two key reasons for the current practical
problems of software engineering, namely ‘‘non-compliance with best-practice
principles’’ as well as ‘‘non-existence of credible evidence regarding the effects of
method and tools’’ (Rombach and Seelisch 2008). This lead them to the discussion
of the relationship between software engineering and computer science (informat-
ics), in continuation of a previous contribution to this discourse (Broy and Rombach
2002). About the relation between software engineering and computer science they
wrote: ‘‘Computer science is the well-established science of computers, algorithms,
programs and data structures. Just like physics, its body of knowledge can be
characterized by facts, laws and theories. But, whereas physics deals with natural
laws of our physical world, computer science is a body of cognitive laws’’
(Rombach and Seelisch 2008). Moreover: ‘‘when software engineering deals with
the creation of large software artifacts then its role is more similar to mechanical
and electrical engineering where the goal is to create large mechanical or electronic
artifacts. (...) In this sense, software engineering can be seen as an analog set of
methods for developing software, based on fundamental results from computer
science’’ (Rombach and Seelisch 2008). Thus, in contrast to the viewpoint of Eden
(2007), wherein software engineering appeared like one particular ‘paradigm’ of
computer science (i.e.: a particular way of ‘doing’ computer science), software
engineering appeared in Rombach and Seelisch (2008) as an autonomous
engineering discipline on the basis of computer science.
It is not the purpose of this essay to discuss comprehensively the extent of
structural and methodological similarity between computer science and physics
which Rombach and Seelisch have asserted in their essay; such an analogy was also
mentioned by Eden (2007) in its section on the ‘scientific paradigm’. At this
moment in time it seems to me that such an analogy between computer science and
physics, as asserted by Rombach and Seelisch (2008), is currently more wishful
thinking than observable reality, but anyway this is a topic of discussion rather for
the ‘classical’ philosophy of computer science about which some volumes of
publications already exist.
8
This essay is mainly concerned with software
engineering and its relation to other disciplines, not the meta-scientific disputes
about those other disciplines themselves, though it should also be clear that there
must be some topical overlap between the philosophy of computer science and the
8
About the philosophy of computer science at least two special editions have already appeared in print:
one in this journal, Minds and Machines (Springer-Verlag 2007), and another one in the Journal of
Applied Logic (Elsevier 2008), see http://pcs.essex.ac.uk/. There are also textbooks such as Floridi (1999)
and Colburn (2000).
S. Gruner
123
philosophy of software engineering, in correspondence with the topical relationships
between computer science and software engineering themselves; (see the further
discussions below).
Rombach and Seelisch continued their discussion with the topic of software
engineering ‘‘principles’’, especially the ‘‘general pattern of divide and conquer’’,
which is a reductionist method of separating a large problem into a set of smaller
(and thus easier solvable) sub- and sub-sub- problems under the a-priori assumption
that the whole will not be more than the sum of its parts. Terminologically one may
criticize, perhaps somewhat pedantically, that a ‘‘principle’’ in the terminology of
Rombach and Seelisch should be better called a ‘maxim’, such as not to confuse
ontology and deontology, world and method. However, pedantic terminology aside,
there must surely arise the question about the limits of ‘principles’ such as ‘divide
and conquer’ themselves: Classically—and apparently also in Eden (2007)—one
had almost always tacitly presumed rather simple hardware structures, such as the
Zuse/von-Neumann computer architecture (or rather simple networks composed of
such devices), as the material basis for which software systems were to be
developed. However, with the possible emergence of other hardware systems such
as massive-parallel cellular automata in the not-too-far future, our cherished
‘principles’ (such as our methodical reductionism) might possibly falter. In the
words of Victor Zhirnov and his co-authors this forecast reads as follows: ‘‘When
we consider the use of these systems’’ (i.e., cellular automata) ‘‘to implement
computation for general applications, a vexing set of software challenges arise (...)
and we are aware of little work in this area’’ (Zhirnov et al. 2008). In other words:
At stake is, from a science-philosophical perspective, the principle-ness of those
software engineering concepts which had been so far regarded as ‘principles’ under
un-reflected, accidental historical circumstances (such as the technical and
technological dominance of the Zuse/von-Neumann machine) which had simply
been taken for granted during several decades of our times. In this context, software
engineering philosophy must thus ask the question: What is the characteristic
feature of a software engineering ‘principle’, and are we really confronted with
(genuine) principles when practical software engineers speak about such? Such a
philosophical concept analysis—for example on the notion of ‘principle’—might
then lead to further ‘paradigmatic’ insights, similar to what has been shown in Eden
(2007).
Regarding the demanded empirical evidence in software engineering—see for
comparison the ‘scientific paradigm’ in Eden (2007)—Rombach and Seelisch stated
‘that having definitions and measures at one’s disposal does not automatically
guarantee that they be used. Enforcing their usage must be part of the project and
can often only be accomplished by organizational changes or even changes in the
working culture’’ (Rombach and Seelisch 2008). At this point I can see Rombach
and Seelisch (2008) going a step further than Eden (2007) in which one cannot find
sufficient mentioning of any kind of ‘meta method’ for an effective ‘cultural’
transition from the (rejected) ‘technocratic’ to the (desired) ‘scientific paradigm’
(Eden 2007). Moreover, here I can also see a ‘door’ into the domains of
philosophical ethics and philosophical anthropology with the question whether or
not any change of our ‘working culture’ is arbitrarily at our disposal, or if there
Problems for a Philosophy of Software Engineering
123
exists anything like a ‘human nature’ on which our ‘working culture’ might depend
deeply in a non-arbitrary manner. The general presumption of Rombach and
Seelisch (2008) seems to be that such a change in our working culture can be
achieved at will.
A normative question would follow immediately: should such a work-cultural
transition (under the assumption of its possibility) be made at all? In this context it is
interesting to note that the software engineer Tom DeMarco, previously known as a
strong supporter of rigorous metrics and quantitative measurements in the software
engineering process (De Marco 1986), such as advocated by Rombach and Seelisch
(2008), has recently dissociated himself from his earlier positions and is now
strongly emphasising the importance of ethical concepts such as ‘value’ and
‘purpose’ beyond the technical requirements of quantitative control and control-
lability (De Marco 2009). Contrary to Rombach and Seelisch’s remarks regarding
physics as the role-model discipline for computer science and software engineering,
DeMarco claimed recently that ‘‘software development is inherently different from
a natural science such as physics, and its metrics are accordingly much less precise
in capturing the things they set out to describe. They must be taken with a grain of
salt, rather than trusted without reservation’’ (De Marco 2009).
Here we have arrived at a crucial science-philosophical and methodological point
in the software engineering debate again, where—in structural analogy to Eden
(2007)—three major ‘parties’ can be identified:
The ‘formalists’ emphasise the mathematicalness of software engineering and
advocate mathematical methods for software quality assurance, such as
theorem-proving and model-checking.
The ‘engineers’ emphasise the constructivity of software engineering along the
lines of rigorous production schemes and workflow models, as they are also
known from mechanical factories.
The ‘humanists’ emphasise the social interactions during the process of software
development, and the implications of software applications in the wider society.
In Gruner (2010) I have also spoken about the ‘physicalists’ (for which Rombach
and Seelisch (2008) can be taken as a good example). This position of software
engineering physicalism can be analysed as a combination of the ‘formalists’ and
the ‘engineers’ of above, whereby the engineering practices are supposedly based on
physics-like experimental experiences, and the formulation of physics-like general
laws is supposedly based on the precision of the language of mathematics. Software
‘physicalism’ in the terminology of Gruner (2010) thus matches the ‘scientific
paradigm’ of Eden (2007).
In this context, DeMarco has explicated and paraphrased the ‘humanist
paradigm’ as follows: ‘‘I’m gradually coming to the conclusion that software
engineering is an idea whose time has come and gone. I still believe that it makes
excellent sense to engineer software. But that isn’t exactly what ‘software
engineering’ has come to mean. The term encompasses as specific set of disciplines
including defined processes, (etc.) All these strive for consistency of practice and
predictability. Consistency and predictability are still desirable, but they haven’t
ever been the most important things. For the past 40 years (...) we’ve tortured
S. Gruner
123
ourselves over our inability to finish a software project on time and on budget. But
(...) this never should have been the supreme goal. The more important goal is
transformation, creating software that changes the world (...). Software development
is and always will be somewhat experimental. The actual software construction isn’t
necessarily experimental, but its conception is. And this is where our focus ought to
be’’ (De Marco 2009).
In terms of classical philosophy, DeMarco’s optimistic statement sounds very
much like American Pragmatism; yet it remains to be demonstrated whether or not
such pragmatism will be able pull the discipline of software construction by its own
hair out of swamp in which it is notoriously sitting (like in the story of
Mu
¨nchhausen). DeMarco’s is indeed an optimistic point of view, based on the
‘common sense’ experience that we are not daily confronted with catastrophic
Ariane 5 incidents and that our daily interaction with mundane household software
products (e.g., eMail, internet, mobile telephony, computer games, etc.) is—in spite
of the occasional ‘hickup’—reasonably pleasant and successful. In other words:
DeMarco simply refused to accept the notorious ‘software crisis’—by which much
software philosophy, including Rombach and Seelisch (2008), is motivated—as a
crisis at all. This refusal must point, in the end, to related questions in social
philosophy and the philosophy of systems about the concept and the essence of what
we want to call a ‘crisis’. For comparison: we would (at this point in time) also not
easily want to assert that the entire discipline of civil engineering (as a whole)
would be ‘in crisis’, though we all know that many streets and roads are still rather
poorly built, some hardware structures still collapse catastrophically every now and
then, and also many civil engineering projects—not only software engineering
projects—are running late and over-budget, as many town mayors and municipal
directors can tell.
From the perspective of Eden (2007) the viewpoint of De Marco (2009)is
interesting, too, because it cannot be captured adequately by any of Eden’s three
‘paradigms’ alone: DeMarco’s viewpoint is not in contradiction to any of those
three (Eden 2007); it is located somewhat ‘orthogonal’ to (or even beyond) all of
them, and thus adds another dimension to our software-philosophical problems
under consideration.
The issue of ‘experimental-ness’ of software engineering, vaguely mentioned by
DeMarco in his quote of above, shall now lead us back to the discussion of the
issues emphasised in Rombach and Seelisch (2008) in which the authors demanded:
‘Laying the foundations of software engineering thus means to:
state working hypotheses that specify software engineering methods and their
outcome together with the context of their application,
make experiments, i.e. studies to gain empirical evidence, given a concrete
scenario,
formulate facts resulting from these studies (...),
abstract facts to laws by combining facts with similar, if not equal, contexts,
verify working hypotheses, and thereby build up and continuously modify a
concise theory of software engineering as a theoretical building block of
computer science’’ (Rombach and Seelisch 2008).
Problems for a Philosophy of Software Engineering
123
As mentioned above, all this seems very compatible with the notion of the
‘scientific paradigm’ of computer science in Eden (2007). Thus, using Eden’s
terminology we could, in the case of Rombach and Seelisch (2008), speak of an
example of the ‘scientific paradigm’ of software engineering, which implies that we
cannot easily subsume the entire domain of software engineering under the
‘technocratic paradigm’ of computer science (as it was suggested in Eden (2007)).
The lengthy quote of above contains the core of Rombach’s and Seelisch’s
basically empiricist software engineering philosophy. Structurally we can imme-
diately recognize their adherence to the ideal of physics as the role-model science,
with their mentioning of hypotheses, experiments, facts and laws. However, once
again the science-philosophical question arises whether or not (and, if yes, to what
extent) such a structural analogy is materially justified. For example, Rombach and
Seelisch did not clarify (and did not even attempt to clarify) their notion of
‘experiment’, especially (not) as far as the crucial, classical criterion of repeatability
is concerned. How would software engineering ‘experiments’ be controlled and
isolated from their environment under laboratory conditions, which is the classical
precondition of repeatability? Has any ‘software engineering experiment’ in the
history of science ever been de-facto repeated? And if repeatability cannot be
granted in the classical sense, which is then the degree of validity of the ‘laws’
which are supposed to be induced from such an ‘experimental’ procedure? These
are the kind of questions which philosophical software engineers like Rombach and
Seelisch should try to answer seriously—otherwise they would immediately run into
the same type of difficulties as Auguste Comte with his empiricist conception of
sociology as the ‘physics of society’ more than 150 years ago. I would like to add
that repeatable experiments (in the classical sense of the term) in software
engineering are possible if the computer itself serves as our well-controlled
‘laboratory’ and if a computer program is the subject of experimentation; see Eden
(2007) for comparison. Then, however, we would have returned into the
comparatively narrow field of computer science and programming, which does
not exhaust the wider field of software engineering in which we have to deal with
larger projects, various human or corporate stake-holders, legal and financial
constraints, and the like. How can all those items and stake-holders be subject to
‘experiments’ in the classical, physics- or chemistry-oriented sense of the term?
Regarding Rombach’s and Seelisch’s methodological concern for the ‘‘verification’
of hypotheses in the domain of software engineering, see Popper’s notion of
falsifiability and the related discussions in Northover et al. (2007,2008).
Also an academic question re-arises from Rombach’s and Seelisch’s above-cited
statement, namely: whether software engineering should be categorized as sub-
discipline of computer science, or whether software engineering should be regarded
as a discipline in its on right, with computer science as its basis and auxiliary
discipline. Such a classification problem was also mentioned in Eden (2007).
Rombach and Seelisch seemed to oscillate between these two classification
alternatives and did not commit themselves to a final decision in this regard.
Rightly, however, it was pointed out in Rombach and Seelisch (2008) that the
immaturity of software engineering as an ‘engineering’ discipline is closely related
to the following practical shortcomings and methodological flaws:
S. Gruner
123
‘Clear working hypotheses are often missing.
There is no time for, or immediate benefit from empirical studies for the team
who undertakes it.
Facts are often ignored (...)’’ and ‘‘often replaced by myths, that is by unproven
assumptions’’ (Rombach and Seelisch 2008).
These desiderata lead the authors to conclude that ‘‘up to now, a concise,
practical theory of software engineering does not exist’’ (Rombach and Seelisch
2008).
The remainder of their paper deals with particular examples of popular software
engineering myths, as well as suggestions of some concrete research questions to
stimulate research programmes—obviously intended as: ’progressive’ (not: ’degen-
erating’) research programmes in the terminology of Lakatos (1978)—with the aim
of eventually being able to replace those myths. In that part of their paper we can
find again much support for what Eden had called the ‘scientific paradigm’, which
we can take at least as one counter-example to his suggestion that software
engineering by-and-large would be dominated by the ‘technocratic paradigm’ (Eden
2007).
Since Rombach’s and Seelisch’s manifesto (Rombach and Seelisch 2008)is
directly related to an earlier contribution by Broy and Rombach (2002), it makes
sense to look at that contribution as well, for the sake of a more comprehensive
understanding of our topic. As an initial explication of ‘software engineering’ we
can find there: ‘‘Purpose of the industrial engineering of software is the development
of large-scale software systems under consideration of the aspects costs, deadlines,
and quality’’ (Broy and Rombach 2002). Already this initial explication by Broy and
Rombach could lead us into a discussion of general philosophy of technics and
technology, whereby we could ask: what constitutes an ‘industry’? Is ‘industry’
about large numbers of people and how they organise their work in a Taylorist or
Fordian manner? Or is it the application of accumulated ‘capital’ (i.e., machinery
and automated tools) in the production process? Is the use of the term ‘software
industry’ materially justified, if we observe that most software producing enterprises
in our days are in fact hardly any larger—in terms of numbers of workers—than the
workshop of a traditional craftsman and his helpers? Is ‘industry’ a rather
misleading metaphor in our context, a metaphor which does not do justice to the
actual way in which software is actually being produced in these days? Or are we
here already dealing with a completely new notion of the term ‘industry’ itself,
which is nowadays no longer associated with traditional images of iron, smoke, and
armies of workers marching through the gates of their factory? Those would surely
be interesting new questions for a more general philosophy of engineering, technics
and technology (Rapp 1974). Though these questions cannot be discussed any
further within the scope of this essay, they clearly tell us that a comprehensive
philosophy of software engineering must reach beyond the scope of our classical
philosophy of computer science in which such questions and problems (e.g.,
industry, organisation of human work, etc.) do not find their suitable place. Figure 1
shows the sketch of a topic map in which the philosophy of software engineering
appears in a wider science- and technics-philosophical context.
Problems for a Philosophy of Software Engineering
123
The main theme of Broy and Rombach (2002) was the question about the degree
of difference or similarity between software engineering and other engineering
disciplines, on the basis of the immateriality of software which distinguishes this
product type from the material product types of all other engineering disciplines.
Particularly Broy and Rombach mentioned:
the difficulties arising from the software’s abstractness,
the software’s multiple aspects of syntax and semantics,
the intrinsically difficult-to-understand, complex and dynamic system behaviour
to which software is only a static description (see again Eden (2007) for
comparison) and, last but not least,
the absence of natural physical constraints as protectors against weird forms of
design and construction.
On these premises Broy and Rombach concluded—whereby these conclusions
may still be regarded as valid today—that:
software engineering as a discipline has not yet reached the degree of
professional maturity which the classical engineering disciplines have already
reached,
‘the discipline is still struggling with its self-understanding’’ (Broy and
Rombach 2002), and
‘foundations and methods are partially still missing’’ (Broy and Rombach
2002).
In the context of Eden (2007) the most interesting part of Broy and Rombach
(2002) is their attempt to classify software engineering in a schema of related
disciplines, with the purpose of contributing to a philosophical self-understanding—
the lack of which they had also identified—of the software engineering discipline.
The main question (which also came up in Rombach and Seelisch (2008) again)
was, whether software engineering is included as a sub-field of computer science (as
it is currently enshrined the academic curricula at many universities, with software
engineering courses being lectured as part of the computer science degree), or
whether software engineering is a field on its own, with computer science as its
separate material and methodological basis. Also Broy and Rombach (2002) had not
reached a decisive solution in this problem, though they seemingly tended towards
Fig. 1 The Philosophies of
Computer Science and Software
Engineering as intersecting
instances of the Philosophies of
Science and Technics/
Technology
S. Gruner
123
the latter solution with the following analogy argument: ‘‘Imagine that physicists
with a specialisation in mechanics would be employed as mechanical engineers!’
(Broy and Rombach 2002). Here, however, we could ask if that was really not just
an argumentum ad hominem, especially if we take into consideration that physicists
are de-facto employed in all sorts of jobs and positions, including positions as
programmers in the software industry. Anyway, the classification scheme by Broy
and Rombach (2002) and Rombach and Seelisch (2008), which was also discussed
in Gruner (2010), looks as depicted in Fig. 2.
In this figure we can see three categories of sciences, namely ‘auxiliary’ sciences,
‘fundamental’ sciences, and ‘engineering’ sciences. Software engineering appears in
the third category together with electrical and mechanical engineering as (some
examples of) its sister sciences. Sciences so different from each other as physics,
computer science, and psychology appear in the category of ‘fundamental’ sciences
(middle layer of Fig. 2), whereas mathematics appears in the bottom layer of Fig. 2
in the role of an ‘auxiliary’ science.
There are some obvious omissions in this diagram which do not need to be
discussed any further. For example, mathematics is obviously a helper science also
to economics, and economics must surely be applied not only in commercial
software engineering (as shown in Fig. 2) but also in commercial mechanical
engineering (no link depicted in Fig. 2)—ditto for psychology, which must
obviously be taken into account also for the design of useful and intuitive user
interfaces in the domain of electrical and hardware engineering.
More interesting about Fig. 2is the question why mathematics does not point
directly also to the engineering sciences (only indirectly via the foundation
sciences)? The diagram in this form (Broy and Rombach 2002) seems to suggest
that whenever a software engineer is applying mathematics, then he is actually
doing computer science, not software engineering. Such a view would be consistent
with Eden’s assertion that the ‘rationalist paradigm’ (of theoretical computer
science) and the ‘technocratic paradigm’ (of software engineering) would have little
or nothing to do with each other (Eden 2007). However this view is in contrast to
other schools of software engineering according to which mathematical methods are
indeed genuine software engineering methods (Kondoh 2000), and thus not only
computer science support methods at the basis of software engineering. As far as
Fig. 2 Classification of Software Engineering according to Broy and Rombach (2002) and Rombach and
Seelisch (2008)
Problems for a Philosophy of Software Engineering
123
this mathematicalness of engineering in general and software engineering in
particular is concerned, Tom Maibaum has recently emphasised two further relevant
points:
‘Engineers calculate, mathematicians prove’; this is a somewhat bold
expression which basically means that engineers are only applying ‘‘distilled
handbook mathematics’’ the rules of which had been developed outside the
realm of engineering (Maibaum 2008).
The branch of mathematics which is most relevant to classical engineering
disciplines is the infinitesimal differential calculus as it was developed since
Leibniz and Newton, whereas the branch of mathematics most relevant to
software engineering is discrete mathematics, including set theory and formal
logics (Maibaum 2008).
Of course it is necessary to calculate in order to prove, and of course also an
engineer (not only a mathematician) wants to ‘prove’ (in a practical sense, with help
of calculation) that some design concept or model appears to be consistent and
feasible for implementation before the related artifact gets produced. But that was
not Maibaum’s point in this discussion. The point is: Whereas the classical
engineering disciplines already have a large library of ‘distilled handbook
mathematics’ available for application, a handbook of formulae readily applicable
for software-engineering-related calculations is yet nowhere to be seen. It is this
situation to which the words ‘‘immaturity’’ and ‘‘lack of foundations’’ in Broy and
Rombach (2002) refer. This lack of ‘handbook mathematics’ for the domain of
software engineering in the sense of Maibaum (2008) might also have been a
motivation for Eden’s classification of software engineering as mainly ‘techno-
cratic’ (Eden 2007). On the other hand, however, it is also true that more and more
mathematical ‘tools’ get applied directly in the domain of software engineering: see
for example the application of graph theory for the purpose of software testing. In
this application domain, graph theory is helpful to design the test experiments which
are then carried out in a practical experimental way (Amman and Offut 2008). If
software testing, as a sub-domain of software engineering, is conducted in such a
way—i.e., when the experimental practice is guided by theory—then we are indeed
well on the way towards what Eden has called the ‘scientific paradigm’ not only in
computer science but also in the wider field of software engineering.
Looking at Fig. 2again we can say that computer science—there regarded as a
‘foundation science’ to software engineering—is surely an issue in and by itself. As
it was rightly remarked in Broy and Rombach (2002), computer science itself is not
a monolithic science. Instead, computer science has various parts and aspects, such
that it ‘‘structures itself (further) into (computer science) as foundation science and
(computer science) as engineering science’’ (Broy and Rombach 2002). Let me give
two simple examples: A formalised theory of Chomsky grammars as well as a large
volume of empirical, practical experience about the design and development of
operating systems are both included in the domain of computer science by-and-
large, whereby the study of formal grammars can well be regarded as a form of
‘mathematics’ whereas the study of operating systems can well be regarded as an
activity of ‘engineering’; (this example is of course somewhat simplified). In Eden
S. Gruner
123
(2007), however, this ‘inner diversity’ of (or within) computer science was not fully
taken into account.
Academically, this diversity within the field of computer science is reflected by
the historically varying placement of computer science departments into different
faculties at different universities. Typically (with some exceptions) we find
computer science either in faculties of mathematics and natural sciences (example:
University of Aachen), or in faculties of engineering and technology (example:
University of Pretoria). Sometimes we also find computer science raised to the level
of a faculty in its own right (example: University of Bremen). This variety was also
mentioned in Eden (2007). In some cases the situation is even more complicated.
Take, for example, the University of Aachen again, where some computer science
chairs even belong to different faculties, though they are all doing computer science:
there, for historic reasons, the chair for operating systems belongs to the faculty of
electronics engineering whereas the chair for compiler construction belongs to the
faculty of natural sciences and informatics, though both operating systems and
compiler construction clearly fall into the category of ‘core’ computer science. As
far as the classification in Eden (2007) is concerned we can thus say that different
‘paradigms’ might be predominant in different sub-areas of computer science (and
software engineering) such that it would be wrong to say that there are different
‘paradigms’ of computer science as a whole. In this context one should also note
that Eden’s entire paradigm scheme is very much based on the ontological question
of ‘what is a computer program’ (Eden 2007), though there are also relevant
branches and sub-areas of computer science (for example: database systems design)
in which computer programs are mainly regarded as auxiliary means to an end on a
higher level of abstraction, and are thus, as such and per se, are not in the centre of
interest.
In summary, the main problem with the classification by Broy and Rombach
(2002), as depicted in Fig. 2, is, as far as I can see, that it treats computer science
too simplistically and too ‘monolithically’ as mathematics-based foundation science
(of software engineering), thereby ignoring other engineering-related sub-sciences
of computer science, such as, for example, operating systems as mentioned above.
Subsequently, a string of problems arises:
If software engineering has been ‘lifted’ out of the domain of computer science
into the domain of engineering (see Fig. 2), should then not, by analogy, also the
field of operating systems be lifted out of computer science into the domain of
engineering? We could consistently continue this game until ‘computer
science’, stripped bare of all its practical aspects, would be little more than
formalised Chomsky grammars and some discrete algebra. Then we would
indeed arrive at a very narrow understanding of ‘computer science’, which
would correspond quite accurately with the ‘rationalist paradigm’ of Eden
(2007).
On the other hand, if we would leave our operating systems where they are,
namely in the domain of computer science, would then not also our operating
systems, according to Fig. 2, belong to the foundations of software engineering?
However, this is really only half of the picture; in fact, operating systems are
Problems for a Philosophy of Software Engineering
123
typically large software systems, which means that software engineering should
now also be listed, vice versa, as a ‘foundation science’ for operating systems
(Northover et al. 2008) within the domain of computer science. In Fig. 2,
however, the link between computer science and software engineering is only
unidirectional, not bidirectional.
In this context, last but not least, it is also interesting to note that the mutual
dependency between computer science and software engineering, or at least
parts thereof (which is not depicted in Fig. 2), corresponds quite well to the
well-known constructivist argument about the mutual dependency between
physics and the engineering of technical artefacts which need to be used for
physical measurements. The constructivist viewpoint is thus in contrast to the
classical interpretation of physics as the foundation of engineering; it is this
classical, non-constructivist which was represented by Broy and Rombach
(2002) in Fig. 2.
As an intermediate summary of the discussion as it has been conducted so far it
seems fair to say that
neither is software engineering only a sub-area (nor ‘paradigm’) of computer
science, because software engineering entails activities such as project
management about which genuine computer science is not concerned,
nor is software engineering simply ‘based on’ computer science in an
unidirectional relation, because several subjects of computer science, such as
operating systems or compilers, are also large-scale software systems and would
not exist without the existence of successful software engineering methods.
9
With reference to Fig. 2(once again), let us now dig even deeper and ask: What
is it that ‘lifts’ software engineering up onto the level of engineering, above the level
of computer science? The answer by Broy and Rombach is: ‘‘experience’’, such that,
for example: ‘‘A new method is perhaps a remarkable result of computer science,
but without robust empirical experiences about its effectivity and limits of
applicability it is not a contribution to software engineering’’ (Broy and Rombach
2002). The corresponding science-philosophical position is schematically depicted
in Fig. 3which is also taken from Rombach and Seelisch (2008) with reference to
Broy and Rombach (2002).
The problem with this science-philosophical position, as far as I can see, is the
implicit equation ‘Software Engineering =Computer Science ?Empiricism’, as
indicated in Fig. 3, which tacitly reduces computer science to purely rationalist,
non-empirical science, similar to the ‘rationalist paradigm’ of Eden (2007), in
contrast to what we have already discussed. On the other hand, computer science
was likened by the same authors to physics, as indicated in Fig. 2: Would the
authors then, by analogy, also assert the equation ‘Engineering =Phys-
ics ?Empiricism’, and thereby reduce physics to pure speculative scholastics
and philosophy of nature (as it has been historically the case throughout the Latin
middle ages)? On the basis of everything what I have discussed above, I cannot
9
The same argument even holds for computer hardware design which is becoming increasingly
dependent on software-based modelling tools.
S. Gruner
123
conclude that empiricism would enter software engineering by ‘addition’ to a purely
rationalist computer science: both computer science and software engineering have
both rationalist and empiricist elements in themselves, and neither can computer
science be fully reduced to (or subsumed by) software engineering, nor can software
engineering be fully reduced to (or subsumed by) computer science, (unless we
would aim at a re-definition of our historically grown terminology in a merely
stipulative way, purely ad-libitum and ad-hoc).
Nevertheless: In spite of the inconsistencies in Broy and Rombach (2002), and
Rombach and Seelisch (2008) as discussed above, the ontological status of software
(which has been more comprehensively discussed elsewhere) was correctly
characterised by Broy and Rombach (2002) as an enhancer of the intellectual
abilities of its users; this feature did not play an important role in the discussions in
Eden (2007). Material hardware, on the contrary to software, is an enhancer of the
bodily abilities of its users. This leads us straight back to the classical machine
theory, formulated already in 1877 by the philosopher of technics and engineering,
Kapp, in his ground-breaking book ‘Grundlinien einer Philosophie der Technik’.
Moreover, related to Heidegger’s notion of ‘equipment’ (Zeug), a software-plus-
computer system has elsewhere been called ‘Denkzeug’ (think-equipment), in
contrast to the ‘Werkzeug’ (work-equipment, tool) of the material world. The same
thought, though not exactly in the same words, was thus rightly expressed in the
software engineering philosophy of Broy and Rombach (2002). At this point we can
thus identify yet another interface between the philosophy of computer science, the
philosophy of software engineering and a more general philosophy of technics and
technology—see Fig. 1again for a sketch of this situation.
Summary and Conclusion
What have we reached? Starting from Eden (2007) and his interesting discussion of
three ‘paradigms’ of computer science, this essay has asked the question if (and, if
Fig. 3 Elements of Software
Engineering according to Broy
and Rombach (2002) and
Rombach and Seelisch (2008)
Problems for a Philosophy of Software Engineering
123
‘yes’: to what extent) the arguments of Eden (2007), in the domain of philosophy of
computer science (including software engineering at the margin), could be mapped
directly into a more general philosophy of software engineering, which is related
to—though not identical with—the more specific philosophy of computer science?
It has been found that not all of the arguments from Eden (2007) are directly
applicable in this case, and several reasons therefore have been presented. More
than in Eden (2007) the question about the ‘engineering-ness’ of software
engineering has been an important theme of this essay. Yet other and further
‘paradigms’ in the domain of software engineering were already discussed in
Northover et al. (2008) and Gruner (2010), to which this essay can thus be regarded
as the continuation of a longer discourse.
In Table 1, adapted from Gruner (2010), I have summarily listed three examples
of engineering disciplines. In the spirit of Broy and Rombach (2002), and Rombach
and Seelisch (2008) I have also included their most important ‘parent’ sciences, plus
some further important features and characteristics. However, as discussed above,
the relations between ‘parent’ sciences and ‘child’ sciences in this table must be
taken ‘with a grain of salt’; in particular they need not necessarily be regarded as
unidirectional. Table 1also highlights the fact that software engineering is less
constrained by the laws of nature than other engineering disciplines; this allows for
more freedom of human ingenuity and leads consequently also a larger room for
errors and mistakes. Note, however, the grammar constraint: programming
languages must always have a well-defined formal syntax. Further differences
between software engineering and other engineering disciplines were already
explained in Gruner (2010), especially as far as the relations and relative ‘weights’
of their design processes versus their production processes are concerned. As it was
shown in Gruner (2010), software engineering—in contrast to other industrial
activities—is characterised by particularly ‘high’ design- and remarkably ‘low’
production costs, which is, of course, a direct consequence of software’s
immateriality; see product type in Table 1. My classification of computer science
as a ‘structural’ science in in Table 1stands in contrast with Denning’s
characterisation of computer science as a ‘natural’ science (Denning 2007),
Table 1 Classification of Engineering Disciplines, adapted from Gruner (2010)
Engineering
Discipline
Mechanical
Engineering
Electronic Engineering Software Engineering
Product Machines Computer Components and
Circuits
Computer Programs
Product Type Material Material Immaterial
Parent Science Classical Physics Electro-Physics Computer Science
Parent Science Type Natural Natural Structural
Construction
Constraints
Law of nature Law of nature and logic Law of logic and
grammar
S. Gruner
123
whereby I justify my opinion by pointing out the minor relevance of language (logic
and grammar) in the domain of energetic natural processes.
Outlook: Open Questions for Future Studies
Since the philosophy of software engineering is relatively new, in comparison to
philosophy of computer science, there is a long list of interesting questions for
future studies and discussions. Though the main contribution of this essay was an
analysis of several ‘paradigms’ of software engineering (in continuation of
Northover et al. (2008) and Gruner (2010), and in comparison with several related
‘paradigms’ of computer science from Eden (2007)), this essay would be very
incomplete if it would not at least hint at some other issues for further investigations
in this new philosophy of software engineering. Such hints shall be given very
briefly in these remaining few sections at the end of this essay.
‘System’, ‘model’ and ‘process’ are three fundamental concepts not only in
computer science (Fetzer 1999) but also in software engineering. Those three terms
can be found in almost every software engineering publication, research paper or
textbook for students. Typically there will be a software development ‘process’ in a
software engineering project, during which a software ‘system’ is being produced in
accordance with a corresponding ‘model’. However, all those three concepts already
have a long semantic history in the terminology of various sciences, such that
software engineering has simply ‘inherited’ these terms and continued their usage
without much language-analytic reflection about their historical semantics. Here I
can also see opportunity for interesting philosophical work in the future, such as to
find out which aspects of the historical semantics of ‘system’, ‘process’ and ‘model’
have been preserved in the terminology of software engineering, and which aspects
of their semantics have been modified or even lost. As mentioned above, such an
investigation cannot be delivered within the scope of this essay any more, but at
least the following hints shall be given:
A ‘model’ in the classical, physical sciences (from which mathematics and
formal logics are here excluded, because they use yet another notion of ‘model’)
is usually constructed by abstraction from something that already exists; for
example the globe on the desk of a foreign minister in politics is a model of our
planet Earth. In software engineering, on the contrary, we typically construct a
‘model’ of a software system before that software system itself comes into
existence. Thus, we can see here a ‘switch of direction’ between domain and
range of the model relation.
According to Roettgers (1983) our modern concept of a ‘process’ as an
observable modification of ‘something’ during the passage of time was strongly
informed by the science of chemistry. Here we could ask if Roettger’s
explanations can be losslessly transferred into the domain of the activity of
software development, or if there is anything specific about a software
development ‘process’ which is not sufficiently covered by the historic
semantics of that technical term. From there we could go even further into
Problems for a Philosophy of Software Engineering
123
the philosophy of processes (since the pre-Socratics: Hegel, Nietzsche,
Whitehead, etc.) and ask whether or not a ‘thing’-based metaphysics (e.g.:
Strawson) would be sufficient at all to capture the essence of software
engineering?
As a software ‘system’, when not being processed by a running computer, we
usually regard something rather static, namely a large set of program files and
the program-call relations within and between those files. As far as I can see,
such a static notion of a software ‘system’ is well compatible with the classical
explication of ‘system’ provided in the late 18th century by Johann Heinrich
Lambert (Diemer 1968), but future investigations would be needed to
substantiate such a claim.
The often-mentioned material ‘nothingness’ of software does not only have
implications for our ability of understanding it (Broy and Rombach 2002); it also
has implications for the semantics of the term ‘software maintenance’, which is a
standard term in every software engineer’s technical vocabulary. Something that is
not material cannot physically decay or wear out; in what sense is it then possible to
speak of ‘software maintenance’? Maintenance of a car means typically, for
example, to replace lost engine oil, or to replace a worn-down tyre by a new one,
such that a previous state of newness is re-established. In the domain of building
architecture, such a fix would be called ‘restoration’, for example of an old villa
from the previous century, at which some broken roof tiles could be replaced by
tiles of identical type. In the usual software engineering terminology, on the
contrary, ‘maintenance’ typically means either:
the replacement of a program file F, which is (and had always been since its
creation) wrong in relation to some requirements specification S, by a new
(different) program file F0which now (hopefully) fulfills the requirements
stipulated by S, or:
the replacement of a program file F, though not wrong with regard to S,bya
new program file Gwhich adds additional functionality and features to a
software system which had previously not been there, because they had not even
been mentioned by its initial requirements specification S. In other words, the
replacement F\Gcorresponds to a later requirements specification modification
S\S0.
In the analogy of our old villa from the previous century, the latter modification
would be called a ‘renovation’ (rather than a ‘restoration’), whereby the villa could
get, for example, an additional door or window at a place were there was previously
only a wall. I have mentioned this little peculiarity of ‘software maintenance’—
more recently even more problematic: software ‘evolution’!—as only one example
of a software engineering terminology which is full of ‘home-grown’ and often un-
reflected metaphors. Language philosophers might perhaps find it interesting to
delve somewhat deeper into this techno-linguistic domain.
In addition to a previous discussion about the comparability of the ontological
status of software and the ontological status of art (Northover et al. 2008) I shall
remark only briefly that the usual debate about whether software engineering is
S. Gruner
123
‘engineering’ or ‘science’ is still confronted by yet another opinion according to
which software engineering is neither ‘science’, nor ‘engineering’, but simply ‘art’
(Edmonds 2007). According to my anecdotal experiences, this position is typically
held by programmers (not software engineers), especially those ones who work in
small or micro-size IT houses. Such claims about software as ‘art’ seem to be at
least partly consistent with the analyses by arts theorists such as Goodman or
Burnham, in the context of which Edmonds has rightly pointed out that the quality
of software systems is also measured in aesthetic categories (Edmonds 2007), in
quite a similar way in which many theoretical physicists (for example: Einstein)
have insisted on an aesthetical-theoretical point of view according to which a
mathematical formulation of a physical law cannot be true if it does not also have
‘beauty’. Here we can perhaps find a modern echo of the ancient Greek notion of
jakor(kalos) in which the concepts of ‘beautiful’ and ‘good’ were not to be
separated. By analogy, also a skillful software engineer would intuitively reject an
‘ugly’ software design plan in almost the same way in which Einstein or other
theoretical physicists would have intuitively rejected an ‘ugly’ formulation of a
physical theory, without being able to reason analytically and with full logical rigor
about such an issue of ‘ugliness’. Thus, a future philosophy of software engineering
might also include some philosophy of aesthetics.
Last but not least I want to mention yet another epistemological issue, namely
about software and knowledge. Many software products seem to be inappropriate or
do not fulfill their intended purpose simply because in many cases we just do not
know ‘how to do things’; we lack the procedural knowledge in many domains and
circumstances. Vice versa one could even assume a very radical epistemological
position and declare: We do not have any knowledge about something unless it is
procedural (algorithmic) knowledge about how to create it.
10
This is related to the
problem of what is ‘creativity’. For example, it is fair to say that we have very good
procedural knowledge about how to create a compiler—in short: we ‘know’
compilers very well. On the contrary we do not have procedural knowledge about
how to create stunning original pieces of art—therefore, in radical terms, we do not
know art, not in this strong sense of ‘knowing’ with which we know compilers
(because we can produce them easily following standardized handbook procedures).
Also in software engineering in general we still have very little (procedural)
knowledge about how to create a software system which adequately fulfills some
arbitrarily given purpose P. This epistemological problem is related especially to the
ongoing efforts in the sub-field of ‘automated software engineering’ (ASE), wherein
we could say: the more software creation processes we can automate (algorithmi-
cally) the better we ‘know’ software engineering, and vice versa. Not everybody
would be willing to assume such a radical epistemological position which says: only
procedural production knowledge is regarded as ‘knowledge’ at all—but this to
discuss is yet another task or problem for an upcoming philosophy of software
engineering.
10
I have heard about such a software-epistemological position in a lecture presented by Manfred Nagl in
the late 1990s.
Problems for a Philosophy of Software Engineering
123
Acknowledgments Thanks to the students of my software engineering seminars at the University of
Pretoria for some interesting discussions in the context of this essay. Thanks also to Tom Maibaum for
some inspiring conversations during the ICFEM International Conference on Formal Engineering
Methods, 2008. Several fruitful discussions with my colleagues Derrick Kourie and Morkel Theunissen
are gratefully acknowledged, too. Last but not least many thanks to the editors of this journal, to the
guest-editors of this special issue, as well as to their anonymous reviewers, for the helpful comments
which they have provided on the pre-print drafts of this essay.
References
Amman, P., & Offut, J. (2008). Introduction to software testing. Cambridge: Cambridge University Press.
Broy, M., & Rombach, D. (2002). Software engineering: Wurzeln, stand und perspektiven. In Informatik
spektrum (Vol. 16, pp. 438–451). Heidelberg: Springer.
Cleland, C. E. (2001). Recipes, algorithms, and programs. In Minds and machines (Vol. 11, No. 2,
pp. 219–237). Dordrecht/Heidelberg:Kluwer Academic Publ./Springer.
Colburn, T. R. (2000). Philosophy and computer science series: Explorations in philosophy. Armonk,
NY: M.E. Sharpe Publ.
De Marco, T. (1986). Controlling software projects: Management, measurement, and estimates. London:
Prentice Hall Publ.
De Marco, T. (2009). Software engineering: An Idea whose time has come and gone? In IEEE Software
(Vol. 26, No. 4, pp. 95–96). IEEE Computer Society Press.
Denning, P. J. (2007). Computing is a natural science. In Communications of the ACM (Vol. 50, No. 7,
pp. 13–18). ACM Press.
Diemer, A. (Ed.). (1968). System und Klassifikation, including three classical essays by Lambert, J. H.
Drei Abhandlungen zum Systembegriff, 1782–1787.
Eden, A. (2007). Three paradigms of computer science. In Minds and Machines (Vol. 17, No. 2,
pp. 135–167). Heidelberg: Springer.
Edmonds, E. (2007). The art of programming or programs as art. In Proceedings of new trends in software
methodologies, tools and techniques (pp. 119–125). IOS Press.
Fetzer, J. H. (1988). Program verification: The very Idea. In Communications of the ACM (Vol. 31, No. 9,
pp. 1048–1063). ACM Press.
Fetzer, J. H. (1998). Philosophy and computer science: Reflections on the program verification debate. In:
T. Bynum & J. H. Moor (Eds.), The digital phoenix: How computers are changing philosophy (pp.
253-273). Basil Blackwell Publ.
Fetzer, J. H. (1999). The role of models in computer science. In The Monist (Vol. 82, pp. 20–36). Hegeler
Institute Publ.
Floridi, L. (1999). Philosophy and computing: An introduction. London: Routledge Publ.
Gruner, S. (2010). Software engineering between technics and science: Recent discussions about the
foundations and the scientificness of a rising discipline. In Zeitschrift fu
¨r allgemeine
Wissenschaftstheorie (Vol. 41, No. 1, pp. 237–260). Heidelberg: Springer.
Kondoh, H. (2000). What is mathematicalness in software engineering? Towards precision software
engineering. In Lecture Notes in Computer Science (Vol. 1783, pp. 163–177). Heidelberg: Springer.
Kroeze, J. H. (2010). Ontology goes Postmodern in ICT. In Proceedings of the SAICSIT’10 Conference,
South Africa (pp. 153–159). ACM Press. ISBN 978-1-60558-950-3.
Lakatos, I. (1978). The methodology of scientific research programmes. In Philosophical papers (Vol. 1).
Cambridge: Cambridge University Press.
Landauer, R. (1961). Irreversibility and heat generation in the computing process. IBM Journal of
Research and Development, 5(3). Reprinted in IBM Journal of Research and Development, 44(1/2),
pp. 261–269, 2000. IBM Press.
Maibaum, T. (2008). Formal methods versus engineering. In Proceedings of the First Iinternational
workshop on formal methods in education and training at the ICFEM’08 international conference
on formal engineering methods, Japan.
Masterman, M. (1970). The nature of a paradigm. In: I. Lakatos & A. Musgrave (Eds.), Criticism and the
growth of knowledge (Proceedings of the 1965 International Colloquium in the Philosophy of
Science ay Bedford College) (Vol. 4, pp. 59–89). Cambridge: Cambridge University Press.
S. Gruner
123
Northover, M., Kourie, D. G., Boake, A., Gruner, S., Northover, A. (2007). Agile software development:
A contemporary philosophical perspective. In Proceedings of the SAICSIT’07 Conference, South
Africa (pp. 106–115). ACM Press. ISBN 978-1-59593-775-9.
Northover, M., Kourie, D. G., Boake, A., Gruner, S., Northover, A. (2008). Towards a philosophy of
software development: 40 years after the birth of software engineering. In Zeitschrift fu
¨r allgemeine
Wissenschaftstheorie (Vol. 39, No. 1, pp. 85–113). Heidelberg: Springer.
Olson, E. T. (1997). The ontological basis of strong artificial life. In Artificial Life (Vol. 3, No. 1,
pp. 113–126). Cambridge: MIT Press.
Rapp, F. (Ed) (1974). Contributions to a philosophy of technology: Studies in the structure of thinking in
the technological sciences. Dordrecht: Reidel Publ.
Roettgers, K. (1983). Der Ursprung der Prozeidee aus dem Geiste der Chemie. In Archiv fu
¨r
Begriffsgeschichte (Vol. 27, pp. 93–157). Meiner-Verlag.
Rombach, D., & Seelisch, F. (2008). Formalisms in software engineering: Myths versus empirical facts.
In Lecture notes in computer science (Vol. 5082, pp. 13–25). Heidelberg: Springer.
Smith, B. C. (1998). On the origin of objects. Cambridge: MIT Press.
Snelting, G. (1998). Paul Feyerabend und die Softwaretechnologie. In Informatik Spektrum (Vol. 21, No.
5, pp. 273–276). New York: Springer. English translation: Paul Feyerabend and Software
Technology. Software Tools for Technology Transfer, Vol. 2, No. 1, pp. 1–5, 1998. Heidelberg:
Springer.
Tichy, W. (2007). Empirical Methods in Software Engineering Research. In Invited lecture, Proceedings
of the 4th IFIP WG 2.4 summer school on software technology and engineering, South Africa.
Zhirnov, V., Cavin, R., Leeming, G., Galatsis, K. (2008). An assessment of integrated digital cellular
automata architectures. In Computer (Vol. 41, No. 1, pp. 38–44). IEEE Computer Society Press.
Problems for a Philosophy of Software Engineering
123
... Yet, we believe that bringing together these two disciplines, and indeed drawing analogies and specifying points of contact between them, may be particularly helpful for those interested in understanding their relations from the descriptive, meta-theoretical perspective, of the philosophy of software engineering [32,68]. ...
... This attempt can be seen not only as a much needed theoretical clarification of the humanist aspects underlying the practice of both software engineers and developers, but also as a foundation for further profitable future reflections and speculations. As noted by [32], currently there are, at least, three major competing paradigms in the philosophy of software engineering. The first one is the so-called 'formalist' approach, which typically emphasises the strong logical and mathematical structure (or base) of software engineering. ...
... The second paradigm is the so-called 'engineering' approach, which emphasises the constructivity of software engineering 1 , along the lines of rigorous production schemes and workflow models, as implemented and directly used in many mechanical factories [62]. Finally, according to [32], the third paradigm characterising current approaches to the philosophy of software engineering, the so-called 'humanist' approach, emphasises the social dimension and collaborative interactions observed during the process of software development, as well as analysing the broader implications of software engineering in the wider society. ...
Conference Paper
Far from being a bizarre pastime, alchemy played a crucially important role in the history of science, being supported and promoted by leading political and scientific figures (such as Rudolf II, Jabir ibn Hayyan, Gerard of Cremona, Adelard of Bath, Roger Bacon, Paracelsus, and even Newton). To understand alchemy, however, one has to approach it from both a material and a spiritual (perhaps philosophical) perspective. On the one hand, alchemists wanted to transform, or better transmute, materials (such as lead into gold). On the other hand, though, alchemists were also aiming at transforming qualities and aspects of themselves. In this paper, we show that Computer Science, and in particular Software Engineering, can be partly understood as alchemical processes. We thus draw analogies and specify points of contact between these two, prima facie, distinct and very distant worlds. In doing so, we also formulate and discuss a number of important questions regarding the nature and metaphysics of computation, that can be of interests to many researchers in computer science.
... Yet, we believe that bringing together these two disciplines, and indeed drawing analogies and specifying points of contact between them, may be particularly helpful for those interested in understanding their relations from the descriptive, meta-theoretical perspective, of the philosophy of software engineering [32,68]. ...
... This attempt can be seen not only as a much needed theoretical clarification of the humanist aspects underlying the practice of both software engineers and developers, but also as a foundation for further profitable future reflections and speculations. As noted by [32], currently there are, at least, three major competing paradigms in the philosophy of software engineering. The first one is the so-called 'formalist' approach, which typically emphasises the strong logical and mathematical structure (or base) of software engineering. ...
... The second paradigm is the so-called 'engineering' approach, which emphasises the constructivity of software engineering 1 , along the lines of rigorous production schemes and workflow models, as implemented and directly used in many mechanical factories [62]. Finally, according to [32], the third paradigm characterising current approaches to the philosophy of software engineering, the so-called 'humanist' approach, emphasises the social dimension and collaborative interactions observed during the process of software development, as well as analysing the broader implications of software engineering in the wider society. ...
Chapter
Far from being a bizarre pastime, alchemy played a crucially important role in the history of science, being supported and promoted by leading political and scientific figures (such as Rudolf II, Jābir ibn Hayyān, Gerard of Cremona, Adelard of Bath, Roger Bacon, Paracelsus, and even Newton). To understand alchemy, however, one has to approach it from both a material and a spiritual (perhaps philosophical) perspective. On the one hand, alchemists wanted to transform, or better transmute, materials (such as lead into gold). On the other hand, though, alchemists were also aiming at transforming qualities and aspects of themselves. In this paper, we show that Computer Science, and in particular Software Engineering, can be partly understood as alchemical processes. We thus draw analogies and specify points of contact between these two, prima facie, distinct and very distant worlds. In doing so, we also formulate and discuss a number of important questions regarding the nature and metaphysics of computation, that can be of interests to many researchers in computer science.
... Yet, we believe that bringing together these two disciplines, and indeed drawing analogies and specifying points of contact between them, may be particularly helpful for those interested in understanding their relations from the descriptive, meta-theoretical perspective, of the philosophy of software engineering [Gruner, 2011], [Northover et al., 2008]. ...
... This attempt can be seen not only as a much needed theoretical clarification of the humanist aspects underlying the practice of both software engineers and developers, but also as a foundation for further profitable future reflections and speculations. As noted by Gruner [2011], currently there are, at least, three major competing paradigms in the philosophy of software engineering. The first one is the so-called 'formalist' approach, which typically emphasises the strong logical and mathematical structure (or base) 6 of software engineering. ...
... The second paradigm is the so-called 'engineering' approach, which emphasises the constructivity of software engineering 1 , along the lines of rigorous production schemes and workflow models, as implemented and directly used in many mechanical factories Naur and Randell [1969]. Finally, according to Gruner [2011], the third paradigm characterising current approaches to the philosophy of software engineering, the so-called 'humanist' approach, emphasises the social dimension and collaborative interactions observed during the process of software development, as well as analysing the broader implications of software engineering in the wider society. ...
Preprint
Full-text available
Far from being a bizarre pastime, alchemy played a crucially important role in the history of science, being supported and promoted by leading political and scientific figures (such as Rudolf II, Jābir ibn Hayyān, Ger-ard of Cremona, Adelard of Bath, Roger Bacon, Paracelsus, and even Newton). To understand alchemy, however, one has to approach it from both a material and a spiritual (perhaps philosophical) perspective. On the one hand, alchemists wanted to transform, or better transmute, materials (such as lead into gold). On the other hand, though, alchemists were also aiming at transforming qualities and aspects of themselves. In this paper, we show that Computer Science, and in particular Software Engineering, can be partly understood as alchemical processes. We thus draw analogies and specify points of contact between these two, prima facie, distinct and very distant worlds. In doing so, we also formulate and discuss a number of important questions regarding the nature and metaphysics of computation, that can be of interests to many researchers in computer science.
... Yet, we believe that bringing together these two disciplines, and indeed drawing analogies and specifying points of contact between them, may be particularly helpful for those interested in understanding their relations from the descriptive, meta-theoretical perspective, of the philosophy of software engineering [Gruner, 2011], [Northover et al., 2008]. ...
... This attempt can be seen not only as a much needed theoretical clarification of the humanist aspects underlying the practice of both software engineers and developers, but also as a foundation for further profitable future reflections and speculations. As noted by Gruner [2011], currently there are, at least, three major competing paradigms in the philosophy of software engineering. The first one is the so-called 'formalist' approach, which typically emphasises the strong logical and mathematical structure (or base) of software engineering. ...
... The second paradigm is the so-called 'engineering' approach, which emphasises the constructivity of software engineering 1 , along the lines of rigorous production schemes and workflow models, as implemented and directly used in many mechanical factories Naur and Randell [1969]. Finally, according to Gruner [2011], the third paradigm characterising current approaches to the philosophy of software engineering, the so-called 'humanist' approach, emphasises the social dimension and collaborative interactions observed during the process of software development, as well as analysing the broader implications of software engineering in the wider society. ...
... According to Gruner [21], the achievements of software engineering made it possible to induce a global social evolution. Nevertheless, partly due to this success and also due to the problems, shortcomings, and failures experienced, a need for philosophical theory of software science and engineering began to emerge [21]. As Pyshkin notes [22], "Despite many formalized ways to represent data models, program structures, execution analysis and verification, and project organization were discovered, software engineering is still far from being an exact science." ...
... "Up to now, a concise, practicable theory of software engineering does not exist'' [23], and its philosophical foundations and premises are not yet well understood. The philosophy of software engineering is related to the philosophy of computer science, but they have their differences; they "are not identical branches of a general philosophy of science" [21]. ...
... If the Q is full (18) (before the decrementing phase), then the blocked entrance is lifted (19). 3. Receiving a customer at counter A blocks this counter (20) and changes its state to busy (21). The customer is processed (22) and released to the outside (23). ...
Preprint
We are pursuing a modeling methodology that views the world as a realm of things. A thing is defined as something that can be created, processed, released, transferred, and received. Additionally, in this modeling approach, a thing is a five-dimensional structure referred to as a thinging (abstract) machine. On the other hand, machines are things that are operated on; that is, they are created, processed, released, transferred, and received. The intertwining with the world is accomplished by integrating these two modes of an entity s being: being a thing that flows through machines and being a machine that processes things. This paper further enriches these notions of things and machines. We present further exploration of the thinging machine model through introducing a new notion called the thing/machine (thimac) as a label of the unity of things/machines. Thimacs replace traditional categorization, properties, and behavior with creating, processing, releasing, transferring, and receiving, as well as the two linking notions of flow and triggering. The paper discusses the concept of thimacs with examples and focuses on the notion of structure as it applies to various diagrammatic modeling methodologies.
... According to Gruner [21], the achievements of software engineering made it possible to induce a global social evolution. Nevertheless, partly due to this success and also due to the problems, shortcomings, and failures experienced, a need for philosophical theory of software science and engineering began to emerge [21]. As Pyshkin notes [22], "Despite many formalized ways to represent data models, program structures, execution analysis and verification, and project organization were discovered, software engineering is still far from being an exact science." ...
... "Up to now, a concise, practicable theory of software engineering does not exist'' [23], and its philosophical foundations and premises are not yet well understood. The philosophy of software engineering is related to the philosophy of computer science, but they have their differences; they "are not identical branches of a general philosophy of science" [21]. ...
... If the Q is full (18) (before the decrementing phase), then the blocked entrance is lifted (19). 3. Receiving a customer at counter A blocks this counter (20) and changes its state to busy (21). The customer is processed (22) and released to the outside (23). ...
Article
Full-text available
We are pursuing a modeling methodology that views the world as a realm of things. A thing is defined as something that can be created, processed, released, transferred, and received. Additionally, in this modeling approach, a thing is a five-dimensional structure referred to as a thinging (abstract) machine. On the other hand, machines are things that are "operated on"; that is, they are created, processed, released, transferred, and received. The intertwining with the world is accomplished by integrating these two modes of an entity's being: being a thing that flows through machines and being a machine that processes things. This paper further enriches these notions of things and machines. We present further exploration of the thinging machine model through introducing a new notion called the thing/machine (thimac) as a label of the unity of things/machines. Thimacs replace traditional categorization, properties, and behavior with creating, processing, releasing, transferring, and receiving, as well as the two linking notions of flow and triggering. The paper discusses the concept of thimacs with examples and focuses on the notion of structure as it applies to various diagrammatic modeling methodologies.
... In its earliest forms, computing was seen as a quest to formalize human thinking into a form that could be reduced to calculation and/or be mechanized. E.g., software-pluscomputer system has been called 'Denkzeug' (thinkequipment), in contrast to the 'Werkzeug' (work-equipment, tool) of the material world [5]. While these early attempts at 'mechanizing thought' provided the mathematical and philosophical underpinnings of what we now call computing [6], they have also left a number of issues in trying to understand what lay at the core of a discipline that has had, and continues to have significant impact on our world, society and culture [7,1,2]. ...
... Historically, 'formalists' among engineers emphasise the mathematical nature of software and advocate mathematical methods such as theorem-proving and modelchecking. 'Engineers' emphasise the constructivity of computing system development while 'humanists' emphasise the social interactions during the process of socio-technical systems development, as well as the implications of computing applications in the wider society [5]. Engineering contributes both to the further development of the 'natural' (mind-independent) environment of computing and to its mind-dependent applications: in business, science and society. ...
... While the goals of the computing discipline are broad, and focus significantly on the process(es) of mechanizing human knowing, they also include the object of mechanizing knowing: the data and information being mechanically 'known' [20]. Addressing both the 'what' and 'how' aspects of the mechanization of knowing, the philosophy of computer science deals predominantly with problems and questions around the nature of computation as a process in time, the physicality or non-physicality of information, or with the question whether or not computer science belongs to the group of mathematical or natural sciences [5,10,21]. These topics all include both the how of mechanizing knowing and the what of mechanizing knowing. ...
... The author in this article uses the philosophical and not the information scientific notion of ontology. In information science, ontology is used to understand and resolve problems related to philosophy of computer science dealing with problems and questions around the physicality or non-physicality of information (Gruner, 2011). "In philosophy, ontology is the basic description of things in the world, the description of what is said to truly exist" (Fonseca, 2007, p. 790). ...
... The author in this article uses the philosophical and not the information scientific notion of ontology. In information science, ontology is used to understand and resolve problems related to philosophy of computer science dealing with problems and questions around the physicality or non-physicality of information (Gruner, 2011). "In philosophy, ontology is the basic description of things in the world, the description of what is said to truly exist" (Fonseca, 2007, p. 790). ...
Article
Full-text available
This theoretical article offers a diachronic analysis that is a rebuttal of ontological hegemony of disability as negative. The article is premised on the Ubuntu paradigm from which African wisdom is mostly anchored in idioms and proverbs. This article emerges as a reflection on a Sesotho proverb: Sehole ho 'Ma-sona ha se lahloe (A child with a disability is never abandoned by the mother). The aim of this article is to demonstrate that Basotho ontology of disability portrays an ubuntu cultural acceptance of people with disabilities as equally human as all human beings. A purposive focus group sample of ten parents of youth with intellectual disability discussed the proverb and shared their experiences of raising a child with disability; and, what the proverb: Sehole ho 'Ma-sona ha se lahloe mean to them? The qualitative data from the focus group was used to support the theoretical adaptation of Basotho ontology in revising the current understanding of disability. The themes reported in this article are: experiences of raising a child with intellectual disability and a child's love begins with a parent.
Chapter
Philosophy of computer simulation has for long tried to answer the question: What makes computer simulation special? Answers normally proceed by giving a demarcation criterion, a property which only holds for computer simulation. The definition by demarcation has also been attempted in different fields, maybe most famously by Popper for science. So it might not come as a surprise that philosophy of mathematics has tried to demarcate computer aided proof. What is remarkable is that the demarcation criteria for computer simulation and computer aided proof are rather similar. As the debate in philosophy of mathematics is more advanced, I will show how its arguments can be translated for the philosophy of computer simulation. I argue that even in the light of computer methods human justificatory capabilities still remain central. In closing I point out, that the focus on justificatory methods like verification/validation in software engineering challenges the traditional philosophical account of engineering.
Article
Full-text available
Is Software Engineering a 'science'? If, yes: what type of science? If no, what is it then?
Book
The highly sophisticated techniques of modern engineering are normally conceived of in practical terms. Corresponding to the instrumental function of technology, they are designed to direct the forces of nature according to human purposes. Yet, as soon as the realm of mere skills is exceeded, the intended useful results can only be achieved through planned and preconceived action processes involving the deliberately considered application of well designed tools and devices. This is to say that in all complex cases theoretical reasoning becomes an indispensable means to accomplish the pragmatic technological aims. Hence the abstracting from the actual concrete function of technology opens the way to concentrate attention on the general conceptual framework involved. If this approach is adopted the relevant knowledge and the procedures applied clearly exhibit a logic of their own. This point of view leads to a methodological and even an epistemological analysis of the theoretical structure and the specific methods of procedure characteristic of modern technology. Investigations of this kind, that can be described as belonging to an ana­ lytical philosophy of technology, form the topic of this anthology. The type of research in question here is closely akin to that of the philosophy of science. But it is an astonishing fact that the commonly accepted and carefully investigated philosophy of science has not yet found its counterpart in an established philosophy of technology.
Article
This article concerns the claim that it is possible to create living organisms, not merely models that represent organisms, simply by programming computers ("virtual" strong alife). I ask what sort of things these computer-generated organisms are supposed to be (where are they, and what are they made of?). I consider four possible answers to this question: (a) The organisms are abstract complexes of pure information; (b) they are material objects made of bits of computer hardware; (c) they are physical processes going on inside the computer; and (d) they are denizens of an entire artificial world, different from our own, that the programmer creates. I argue that (a) could not be right, that (c) collapses into (b), and that (d) would make strong alife either absurd or uninteresting. Thus, "virtual" strong alife amounts to the claim that, by programming a computer, one can literally bring bits of its hardware to life.
Article
It is argued that computing machines inevitably involve devices which perform logical functions that do not have a single-valued inverse. This logical irreversibility is associated with physical irreversibility and requires a minimal heat generation, per machine cycle, typically of the order of kT for each irreversible function. This dissipation serves the purpose of standardizing signals and making them independent of their exact logical history. Two simple, but representative, models of bistable devices are subjected to a more detailed analysis of switching kinetics to yield the relationship between speed and energy dissipation, and to estimate the effects of errors induced by thermal fluctuations.
Article
It is argued that computing machines inevitably involve devices which perform logical functions that do not have a single-valued inverse. This logical irreversibility is associated with physical irreversibility and requires a minimal heat generation, per machine cycle, typically of the order of kT for each irreversible function. This dissipation serves the purpose of standardizing signals and making them independent of their exact logical history. Two simple, but representative, models of bistable devices are subjected to a more detailed analysis of switching kinetics to yield the relationship between speed and energy dissipation, and to estimate the effects of errors induced by thermal fluctuations.
Article
In the technical literature of computer science, the concept of an effective procedure is closely associated with the notion of an instruction that precisely specifies an action. Turing machine instructions are held up as providing paragons of instructions that "precisely describe" or "well define" the actions they prescribe. Numerical algorithms and computer programs are judged effective just insofar as they are thought to be translatable into Turing machine programs. Nontechnical procedures (e.g., recipes, methods) are summarily dismissed as ineffective on the grounds that their instructions lack the requisite precision. But despite the pivotal role played by the notion of a precisely specified instruction in classifying procedures as effective and ineffective, little attention has been paid to the manner in which instructions "precisely specify" the actions they prescribe. It is the purpose of this paper to remedy this defect. The results are startling. The reputed exemplary precision of Turing machine instructions turns out to be a myth. Indeed, the most precise specifications of action are provided not by the procedures of theoretical computer science and mathematics (algorithms) but rather by the nontechnical procedures of everyday life. I close with a discussion of some of the rumifications of these conclusions for understanding and designing concrete computers and their programming languages.
Article
Classical engineering is based on solid scientific and mathematical foundations, but neither the science, nor the mathematics, is simply borrowed from the scientists or the mathematicians. Engineers develop their own formulations of the relevant science and mathematics, adapted to support the engineering knowledge used in design of artefacts. There are many formulations of the same science and mathematics, as classical engineering is highly domain specific. A key question for Formal Methods Education is whether uses and formulations of mathematics used in software engineering should be analogous to the situation in classical engineering described above. The position advocated in this paper is that the classical engineering approach is also crucial for Formal Methods. We may well not be in a position to teach a proper formulation of formal methods until we have developed the appropriate reformulations of the usually mathematically oriented mathematics usually taught in computer science and software engineering programmes.