Scaling software development

Concurrent systems

Shared-memory

Shared-memory communication between memories Mᵢ and processors Pᵢ with i = 1, 2, 3, …, n
  • User friendly: The global address space provides an easy interface to the memory.
  • Fast and uniform: Information sharing between processors is both fast and uniform.
  • Scalability: Adding more processors geometrically increases traffic on the memory-processor path
  • Implicitness: Communication is implicit and, therefore, hard to optimize.
  • Responsibility: The programmer is responsible for synchronizing constructs that ensure correct access of global memory.

Message-passing

Message-passing communication between memories Mᵢ and processors Pᵢ with i = 1, 2, 3, …, n
  • Scalability: Memory is scalable with number of processors. Each processor can rapidly access its own memory without interference and overhead.
  • Responsibility: Elimination of the need for synchronization constructs such as semaphores, monitors, …
  • Distributed: Naturally supports distributed computation
  • Copy overhead: Information exchange among processors requires effort.
  • User unfriendly: No simple mapping of existing data structures (based on global memory)

Transformation to software development

  • processor → developer
  • memory/data → work
  • programmer/user → management
  • computing → development
  • semaphores, monitors, … → meetings, standups, …

Shared-work

  • management friendly: The global address space provides an easy interface to the work.
  • fast and uniform: Work sharing between developers is both fast and uniform.
  • Scalability: Adding more developers geometrically increases traffic on the work-developer path.
  • Implicitness: Communication is implicit and, therefore, hard to optimize.
  • Responsibility: The management is responsible for synchronizing constructs that ensure correct access of global work.

Message passing

  • Scalability: Work is scalable with number of developers. Each developer can rapidly access its own work without interference and without overhead.
  • Responsibility: elimination of the need for synchronization constructs such as meetings, standups, …
  • Distributed: Naturally supports distributed software development
  • Copy overhead: Information exchange among developers requires efforts
  • Management unfriendly: No simple mapping of existing work constructs (based on global work)

Conclusion

  • Shared-work software development: Scrum, Waterfall, V-Model, Kanban, XP, …
  • Message-passing software development: Open source and inner source software development
  • theory and mathematical models
  • metrics
  • optimizations, and
  • evaluations.
  • local work is cheap, information exchange is expensive.
  • managers are not important any more — and this scares them.
  • Research on scaling software development is research about scaling networks.

--

--

--

Software developer and researcher on empirical software engineering.

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

Authenticate with AWS Cognito. It is that simple with the AWS Framework!

Dynamic Provisioning with Jenkins

HashTable

Playing with Scaleway Kosmos — Part #4

#CSENotes 4. Software Engineering

When Gson met Kotlin Data classes

Setting My Hardware Up for a Life of Solitude

RxJava2 Schedulers #1: Demystifying the Computation Scheduler

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Michael Dorner

Michael Dorner

Software developer and researcher on empirical software engineering.

More from Medium

Summary of What I learned in Design Pattern: Observer

Why Do Developers Hate Meetings?

Experienced Developers Use These Practices to Master the Code Review

Software engineering principles and best practices you should follow as a good developer

Software engineering principles