Considering Operating Systems

Operating systems are an important class of software, and one which we will have to capture in our ontology.  I’ve only just started to think about them, and already they offer some interesting questions, many of which will be applicable to all types of software.

  • Definition of OS: The most obvious question is how do we define an operating system?  Is it software that allows you to run software, or software that may be installed on some hardware without any other software?  Although the  term is commonly used it doesn’t seem to be that easy to pin down.  For example, early versions of Windows were based on DOS: do we consider Windows 3.1 as an application running on DOS, or an operating system?
  • Kernels: The core of an operating system is the Kernel – can we use this in any useful ways?  We could, for example, say that Windows 3.1 is an operating system based on the MS-DOS kernel.  Equally, we can define a Linux operating system (including Debian, Ubuntu, etc.) as any OS based around the GNU/Linux kernel.
  • Versions, editions and upgrades: Are Windows XP and Vista different operating systems or just different versions?  What about mobile or server versions of systems?  How do we deal with upgrades such as service packs,?  We also need to handle different ‘editions’ of operating systems, e.g., Windows may come in Starter, Home, and Professional Editions.
  • Rolling versions: A related issue, which is pertinent to all software is how we handle rolling versions.  Operating systems such as Gentoo Linux don’t have version numbers, but are updated continuously by users.
  • Architectures: How do we capture the architecture of a system: is a 64 bit version of an OS different to a 32 bit, and how can such differences be captured?
  • Virtual machines: Returning to the question of ‘what is an operating system‘, the picture is complicated by virtual machines.  If we define an OS as software for running software then the Java Virtual Machine can be considered an OS, which seems intuitively wrong.  Additionally, how do we capture the use of virtual machines such as Virtual Box, which allow one operating system to be run as an application within another (do we need to?).

I don’t think any of these questions are insurmountable, given a little pragmatism, but they do make this an interesting task.

Advertisements

About Andy Brown

Researcher on the JISC-funded SWORD (Software Ontology for Resource Description) project, at the University of Manchester.
This entry was posted in modeling. Bookmark the permalink.

2 Responses to Considering Operating Systems

  1. Pingback: Considering Versions « SWORD

  2. Pingback: Software: An Ontology of Ontologies « SWORD

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s