Nurudeen Lameed, Peter Grogono



Designing software to adapt to changes in requirements and environment is a key step for preserving software investment. As time passes, applications often require enhancements as requirements change or hardware environment changes. However, mainstream programming languages lack suitable abstractions that are capable of providing the needed flexibility for the effective implementation, maintenance and refactoring of parallel and distributed systems. Software must be modified to match today’s needs but must not place even greater strain on software developers. Hence, software must be specially designed to accommodate future changes. This paper proposes an approach that facilitates software development and maintenance. In particular, it explains how the semantics of a program can be separated from its deployment onto multiprocessor or distributed systems. Through this approach, software investment may be preserved when new features are added or when functionality does not change but the environment does.


  1. Andrews, R. G. (2000). Foundations of Multithreaded, Parallel, and Distributed Programming. Addison-Wesley.
  2. Armstrong, J., Virding, R., Wikstrom, C., and Williams, M. (2004). Concurrent Programming in ERLANG. Prentice Hall, second edition.
  3. Bagrodia, R. (1989). Synchronization of Asynchronous Processes in CSP. ACM Transaction on Programming Languages and Systems, 11(4):585-597.
  4. Bal, H. E., Steiner, J. G., and Tanenbaum, A. S. (1989). Programming Languages for Distributed Computing Systems. ACM Computing Surveys, 21(3):261-322.
  5. Barnes, F. and Welch, P. (2003). Prioritized Dynamic Communicating and Mobile Processes. IEE Proceedings - Software, 150(2):121-136.
  6. Barnes, F. R. and Welch, P. H. (2004). Communicating mobile processes. In East, I., Martin, J., Welch, P., Duce, D., and Green, M., editors, Communicating Process Architectures, pages 201-218. IOS Press.
  7. Bernstein, A. J. (1980). Output Guards and Nondeterminisn in CSP. ACM Transaction on Programming Languages and Systems, 2(2):234-238.
  8. Brinch Hansen, P. (1987). Joyce - A Programming Language for Distributed Systems. Software Practice & Experience, 17(1):29-50.
  9. Buckley, G. N. and Silberschatz, A. (1983). An Effective Implememtation for The Generalized Input-Output Construct of CSP. ACM Transaction on Programming Languages and Systems, 5(2):223-235.
  10. Dijkstra, E. W. (1968). Cooperating Sequential Processes. In Genuys, F., editor, Programming Languages: NATO Advanced Study Institute, pages 43- 112. Academic Press.
  11. Grogono, P., Lameed, N., and Shearing, B. (2007). Modularity + Concurrency = Manageability. Technical Report TR E-04, Department of Computer Science and Software Engineering, Concordia University.
  12. Harris, T. and Fraser, K. (2003). Language Support for Lightweight Transactions. ACM SIGPLAN Notices, 38(11):388-402.
  13. Hewitt, C. (1976). Viewing Control Structures as Pattern of Passing Messages. Technical Report AIM-410, Department of Artificial Intelligence, MIT.
  14. Hewitt, C. and Baker, H. (1977). Actors and Continuous Functionals. Technical Report MIT/LCS/TR-194, Department of Artificial Intelligence, MIT.
  15. Hoare, C. A. R. (1978). Communication Sequential Processes. Communications of the ACM, 21(8):666-677.
  16. Hoare, C. A. R. (2004). Communicating Sequential Processes. Prentice Hall International, third edition.
  17. Lee, E. A. (2006). The Problem With Threads. IEEE Computer, 39(5):33-42.
  18. Milner, R. (1980). A Calculus of Communicating Systems. Springer.
  19. Olukotun, K. and Hammond, L. (2005). The Future of Microprocessors. ACM Queue, 3(7):26-34.
  20. Roy, P. V. (2004). General Overview of Mozart/Oz. Slides for a talk given at the Second International Mozart/Oz Conference (MOZ 2004).
  21. Salzer, J. H. (1965). M. I. T. Project MAC. Technical Report MAC-TR-16, Department of Artificial Intelligence, MIT.
  22. Schneider, F. B. (1982). Synchronisation in Distributed Programs. ACM Transaction on Programming Languages and Systems, 4(2):125-148.
  23. Silberschatz, A. (1979). Communication and Synchronization in Distributed Programs. IEEE Transaction on Software Engineering, 5(6):542-546.
  24. Sutter, H. (2005a). The Free Lunch Is Over - A Fundamental Turn Toward Concurrency in Software. Dr. Dobb's Journal, 30(3). Available online at
  25. Sutter, H. (2005b). The Trouble With Locks. Dr. Dobb's Journal.
  26. Varela, C. and Agha, G. (2001). Programming Dynamically Reconfigurable Open Systems with SALSA. ACM SIG PLAN Notices, 36(12):20-34.

Paper Citation

in Harvard Style

Lameed N. and Grogono P. (2008). SEPARATING PROGRAM SEMANTICS FROM DEPLOYMENT . In Proceedings of the Third International Conference on Software and Data Technologies - Volume 1: ICSOFT, ISBN 978-989-8111-51-7, pages 63-70. DOI: 10.5220/0001877300630070

in Bibtex Style

author={Nurudeen Lameed and Peter Grogono},
booktitle={Proceedings of the Third International Conference on Software and Data Technologies - Volume 1: ICSOFT,},

in EndNote Style

JO - Proceedings of the Third International Conference on Software and Data Technologies - Volume 1: ICSOFT,
SN - 978-989-8111-51-7
AU - Lameed N.
AU - Grogono P.
PY - 2008
SP - 63
EP - 70
DO - 10.5220/0001877300630070