Aristole and the definition of software applications

Somehow I cannot publish two comments I received for my proposal for a stricted definition of the term "application", so I´m publishing them this way with my comments:

Mujtaba Syed wrote "Have you heard of this 'indirect' definition: 'There is only one application. And it's still being written.'" I have to admit, I haven´t heard about this definition - and I don´t see any value in it. This definition does not attribute any use to the term "application". Because if either the one (and only) application is all code being written or it is developed at some unknown place, it is irrelevant to us. Yet in my day to day life developers and customers alike are talking about "applications" all the time, so "applications" are real and relevant to them - although they might mean different things when they use the term. Unfortunately I have to say, Mujtaba´s definition makes even more obviuous the fundamental problem I yesterday felt exists: there is no clear definition of what an "application" is.

John Cavnar-Johnson then replied to me with "I think you're going down the wrong track here. Are you familiar with Aristotle's four causes? I would argue that you're making the mistake of assuming that you can define an application based on its constituent parts. If, instead of an application, I asked you, "What is a statue?" would you say it's bronze? No, a statue can be made of bronze or marble or any number of materials. A statue is a statue because the artist is using the material at hand to represent something else. A statue is defined by its purpose.
Likewise, an application is not defined by the programming artifacts we use to create it. Instead, it's defined by the users' requirements. An application is a collection of software, hardware, and other artifacts that allow users to accomplish a goal. You may be satisfied with your description, but it's fundamentally wrong."
I like John´s reply because he tries to find a sound fundament for his argument, that my definition is wrong. However, it´s sad John does not provide a better definition of "application" either.

Now, however, after some thinking I don´t agree with John: Aristotle defined 4 causes for everything being:

  • causa materialis: the material something is made from.
  • causa formalis: the form/shape of a being.
  • causa efficiens: the causing agent.
  • causa finalis: the purpose.

Applying these causes to software applications (or short: applications) according to my definition is esay, I´d say: applications are made of IL-code (causa materialis). This code is shaped into assemblies with ever differing interfaces, each application has its own assemblies which look different from those of other assemblies. Some may be the same (e.g. 3rd party controls or the host), but most of them are individually crafted. In total they define the shape of an application (causa formalis). The team developing those assemblies are the causa effciens. And the purpose of the application is to solve a customer´s/user´s problem, e.g. writing an invoice (causa finalis).

Since "my" applications can be described very precisely in the line of Aristotle´s thinking I feel my definition is useful. It is able to describe a being.

So where John sees me erring fundamentally I on the other hand feel supported by the ancient authority he mentions. And I´d like to ask John in return: Why can´t I define a thing by enumerating it´s attributes? A knife is the combination of handle and blade fitting in my hand. Blade and handle can take all sorts of shapes and can be made of many different materials. Its purpose is "cutting" (at least mostly). If the handle-blade combination exeeds a certain size it becomes a sword. And I´d say I recognize a knife when I see one, I can distinguish it from a spoon or sword or lance.

Likewise with my definition I can recognize a software application when I see one: When you show me a host-my code combination I can point at it and say "application". (Which other definition of "application" make it as easy to say "This or that exactly is the application."?) And when you are talking of your application I can ask specific questions, like "What is the host of your application?" or "Where does your application run?". Especially the latter question could not be asked without a precise definition of "appliation".

Being able to ask precise questions and categorize beings and delineate them is the purpose of definitions. That´s what I think my proposal for "application" achieves.

If I left out the "purpose" of an application for a moment, please excuse me. I deem it obvious that applications are host-my code combinations for a very specific purpose. But let me touch up my definition:

A software application consists of exactly one host assembly (EXE) and one or many custom made assemblies (DLLs) developed for a specific purpose. (Of course host as well as custom made assemblies rely on other infrastructure like operating system or .NET Framework.) The combination of my code written to solve a problem and a host containing and running the code make an application. I think, it can and should be as simple as that.

Then, if I choose to develop code to be hosted in several hosts (like a Web service running in IIS/ASP.NET on a server + a WinForms frontend running on clients + some businesslogic running in COM+ on a server and called by the Web service + some stored procedures running in SQL Server called by the COM+ components) I end up with a solution consisting of several applications (4 in this example). Why not? There is no rule saying "Thou shalt solve a customer problem with just one application." The customer doesn´t care anyway. If anything at all he will acknowledge how precisely I can speak about his solution. For the first time he will be able to understand what is meant by the omnipresent term "application"; it´s not the combination of frontend and Web service, it´s not everything together. His solution consists of several applications. And each application consist of a host and several custom made components run by the host.


  • @Andrew: I like those definitions too - but we´re in computer science and even your reference lists "A computer program with a user interface" as a definition of "application". Now my question is: what is a computer program? Back in the good old days it was a single EXE (aka a "monolithic application"). But today? Is a MS Word add-in a "computer program"? Or is an assembly hosted in COM+ a "computer program"? I think the cited definition for "application" is outdated and thus imprecise. And what do you mean by "entry point"? The Main() method of a EXE assembly? Or the operations on a Web service? I agree, it takes more than an executable file to apply to a problem. But does that mean, my proposed definition is too shallow?

  • I didn't mean main(), just the way the user gets it started, whether clicking on winword.exe or getting to an embeded word object in something else.

    I think for most people, and application is something that runs and that they interact with after they click a shortcut.

  • @Andrew: I agree with you that "most people" think of an application in terms of what the can see and start. But I´m not concerned with a user´s view on software development. A user is not interested in whether his application is distributed or not. But we as software developers need to be clear what it means when we say "distributed application" or just "application". So where is the application when I start Word hosting my add-in? What´s the app, when I wrote a WinForms frontend, a Web service and some stored procs? Is that 1 application or several? Unless we have a clear definition, we cannot say. That´s why I proposed my definition.

Comments have been disabled for this content.