This post is based on the slides from my talk at dev8D and various research proposals and essays.
Although it’s a relatively young discipline, software design already has a rich history, punctuated by epic failures, a lot of innovation and incredible successes. Indeed, With the explosion of the Web, it could be argued that the idea of ‘software’, and more precisely the process through which new information-technology-based interactive systems are created and adopted has now a strong influence on the life of a growing number of people.
The problem with all these recent technologies is that they evolve so fast that it becomes very difficult to try and understand exactly what’s happening. Although new amazing and exciting interactive systems appear almost everyday, it becomes difficult to understand what makes a good system, and the reason why particular applications gain immediate attention where very similar ones, which may have appeared a long time before these, are completely ignored.
As a first step towards trying to gain a better understanding of the relationship between humans and interactive systems, it seem to make sense to try and borrow from sociological or psychological literature. However, technology seem to appear sometimes as a rather daughting subject and which can quite easily become charged with cultural and sociological values: Each person brings his or her own experiences and ways of experiencing technology, and a developer for example will have a very different view of the system he or she is developing when compared with other stakeholders of a development project, a typical example being a regular user of the system.
Indeed, this (cultural? social?) gap between developers and users has become more and more salient over time, as development methodologies such as agile where developed with an emphasis on communication, people, and values.
Thus, almost on “argument’s sake”, it could be interesting to explore the history of software development methodologies, to see how these particular ‘discourses’ have been produced over time, and how the meaning of what we could call an ‘application’ or a piece of software.
The history of software design methodologies (where the term methodology is understood as a group of methods and techniques for the elaboration of software applications) could be roughly divided in three main phases. First, as the need for software to support an increasing number of human tasks grew, inspiration was taken from the industrial world and software design processes where based for instance on the ‘waterfall’ model (Royce, 1970), where parts of the development such as planning and prototyping where followed by the actual coding of the piece of software, which would then be tested and finally released, all in a very sequential and planned manner.
A few significant dates in the history of computer science
In 1968, it was brought to consideration that a large amount of software projects where failing, resulting in what was deemed a ‘software crisis’. Later, new software development methodologies started to appear, as the software development field continued to diversify professionally.
In the same time, multidisciplinary approaches such as human-computer interaction, mixing psychology and computer science, started to gain academic momentum. As the need to consider the interactions between users and the system and of properly eliciting their requirements started to take the central stage, new development methodologies such as agile and user-centric iterative development approaches where designed and applied with success to a growing number of software projects.
This strong emphasis on ‘users needs’ which appeared relatively recently in the history of software development, and the success of software development methods highlighting the importance of values as well as issues of meaning and communication between the various stakeholders of a software development project seem to suggest an evolution of development methodologies as a particular form of discourse from a focus on technology and the ‘inner workings’ of a software system to a focus on users, interactions, and therefore the social aspect of this activity.
Thus, it seems clear that a shift in the way ‘software development’ is perceived seem to have happened where discourse about this particular topic started to integrate more and more concerns about interactions between users, systems, and system developers.
What we could argue is that this evolution makes the adoption and adaptation of theoretical frameworks borrowed from social sciences becomes more and more of a necessity and even a necessary step in the evolution of, to speak widely, ‘computer science’. It appears that these adaptations and borrowings have so far been rather gestural, and that there is a lot yet to explore in the way social theory can help us understand ‘interactive systems’, for lack of a better word…
A quick sum up:
- Late 60s : Emergence of a professionalised software engineering field: ‘software developer’ becomes a job
- 68 : The software crisis: the failure of numerous large software projects led to a realisation of the pitfalls inherent to software development
- 80s to 00s: Looking for new directions, growing importance of Human-Computer Interaction principles, apparition of the ‘Interaction Designer’; further professional specialisation.
- Now: Increase in the use and elaboration of user-centred and agile development methods; increasing role of usability principles in design. Focus towards the social possibilities offered by technology: Web 2.0 and ‘social media’, pervasive and ubiquitous computing. Apparition of Behaviour-driven development (BDD). Semantic web…
Related posts:
- Research proposal : A Foucauldian analysis of the evolution of the discourse about software development methodologies
- Towards explicitly sociologically-oriented software development methodologies: using social science to inform software design
- What does the apparition of agile and user-centric development methodologies mean from an interdisciplinary point of view?
- Research proposal: a Bourdieusian ethnographic study of agile development methodologies
- Software as Discourse