Bibliography


Andrews, G.R. (1991). Concurrent Programming: Principles and Practice. Redwood City, CA: Benjamin/Cummings Publishing Company.

Ball, T. and Rajamani, S.K. (2002). The SLAM Project: Debugging System Software via Static Analysis. POPL 2002, 1 – 3.

Balzer, R.M. (1971). PORTS: a method for dynamic interprogram communication and job control. Proceedings AFIPS SJCC Computer Conference, 39, 485 – 489.

Ben-Ari, M. (1990). Principles of Concurrent and Distributed Programming. Prentice-Hall International Series in Computer Science.

Birtwistle, G.M., Dahl, O., Myhrhaug, B. and Nygaard, K. (1973). SIMULA BEGIN. New York: Van Nostrand Reinhold.

Booch, G. (1986). Object-oriented development. IEEE Transactions on Software Engineering SE-12, 2 (February), 211 – 221.

Booch, G., Rumbaugh, J. and Jacobson, I. (1998). Unified Modeling Language User Guide. Addison-Wesley Object Technology Series.

Brat, G., Havelund, K., Park, S. and Visser, W. (2000). Java PathFinder – Second Generation of a Java Model Checker. Workshop on Advances in Verification.

Brinch-Hansen, P. (1970). The nucleus of a multiprogramming system. Communications of the ACM 13, 4 (April), 238 – 241.

Brinch-Hansen, P. (1972). Structured multiprogramming. Communications of the ACM 15, 7 (July), 574 – 578.

Brinch-Hansen, P. (1975). The programming language Concurrent Pascal. IEEE Transactions on Software Engineering SE-1, 2 (June), 199 – 206.

Brinch Hansen, Per (2002). The Origins of Concurrent Programming: From Semaphores to Remote Procedure Calls. Springer-Verlag.

Bruno, G. (1995). Model-Based Software Engineering. London: Chapman & Hall.

Burns, A. and Davies, G.L. (1993). Concurrent Programming. Wokingham: Addison-Wesley.

Carriero, N. and Gelernter, D. (1989a). Linda in context. Communications of the ACM 32, 4 (April), 444 – 458.

Carriero, N. and Gelernter, D. (1989b). How to write parallel programs: a guide for the perplexed. ACM Computing Surveys 21, 3 (September), 323 – 358.

CCITT (1993). CCITT High Level Language (CHILL) Recommendation Z200. Geneva: International Telecommunication Union ITU.

Chandy, K.M. and Misra, J. (1984). The drinking philosophers problem. ACM Transactions on Programming Languages and Systems 6, 4 (October), 632 – 646.

Cheung, S.C. and Magee, J.N. (1991). Parallel algorithm design for workstation clusters. Software: Practice and Experience 21, 3 (March), 235 – 250.

Cheung, S.C. and Kramer, J. (1999). Checking safety properties using compositional reachability analysis. ACM Transactions on Software Engineering and Methodology (TOSEM) 8, 1 (January), 49 – 78.

Ciancarini, P. and Hankin, C. (eds.) (1996). Coordination Languages and Models. Proceedings of Coordination ‘96, LNCA 1061, Berlin: Springer-Verlag.

Clarke, E.M., Emerson, E.A. and Sistla, A.P. (1986). Automatic verification of finite state concurrent systems using temporal logic specifications. ACM Transactions on Programming Languages and Systems 8, 2 (April), 626 – 643.

Clarke, E.M., Wing, J.M., et al. (1996). Formal methods: state of the art and future directions. ACM Computing Surveys 28, 4, 626 – 643.

Cleaveland, R., Smolka, S.A., et al. (1996). Strategic directions in concurrency research. ACM Computing Surveys 28, 4, 607 – 625.

Cobleigh, J.M., Clarke, L.A. and Osterweil, L.J. (2002). FLAVERS: a finite state verification technique for software systems. IBM Systems Journal 41, 1, 140 – 165.

Coffman, E.G. Jr., Elphick, M.J. and Shoshani, A. (1971). System deadlocks. ACM Computing Surveys 3, 2 (June), 67 – 78.

Corbett, J., Dwyer, M., Hatcliff, John, et al. (2000). Bandera: Extracting Finite-State Models from Java Source Code. Proceedings of 22nd IEEE/ACM International Conference on Software Engineering (ICSE-2000), Limerick, Ireland, 439 – 448.

Cunningham, R.J. and Kramer, J. (1978). An exercise in program design using SIMULA class invariants. Software: Practice and Experience 8, 3 (May – June), 355 – 369.

De Nicola, Rocco, Ferrari, Gianluigi and Meredith, Greg (eds.) (2004). Coordination Models and Languages. 6th International Conference, COORDINATION 2004, Pisa, Italy, Proceedings, LNCS 2949, Berlin: Springer-Verlag.

Department of Defense (1983). Reference Manual for the Ada Programming Language. New York: Springer-Verlag.

Dijkstra, E.W. (1965). Solution of a problem in concurrent programming control. Communications of the ACM 8, 9 (September), 569.

Dijkstra, E.W. (1968a). Cooperating sequential processes. In F. Genuys (ed.) Programming Languages, 43 – 112. New York: Academic Press.

Dijkstra, E.W.D. (1968b). A constructive approach to the problem of program correctness. BIT8, 3, 174 – 186.

Dijkstra, E.W. (1972a). A class of allocation strategies inducing bounded delays only. AFIPS Spring Joint Computer Conference SJCC, 933 – 936.

Dijkstra, E.W. (1972b). Hierarchical ordering of sequential processes. In C.A.R. Hoare and R.H. Perrott (eds.) Operating System Techniques. New York: Academic Press.

Dwyer, M.B., Avrunin, G.S. and Corbett, J.C. (1999). Patterns in Property Specifications for Finite-State Verification. Proceedings of the 21st International Conference on Software Engineering (ICSE’99), Los Angeles (May).

Floyd, R. (1967). Assigning Meaning to Programs. Symposium on Applied Mathematics, New York, 19 – 32.

Fowler, M. and Scott, K. (1997). UML Distilled: Applying the Standard Object Modeling Language. Addison-Wesley Object Technology Series.

Francez, N. (1986). Fairness. New York: Springer-Verlag.

Freeman, Eric, Hupfer, Susanne and Arnold, Ken (1999). JavaSpaces™ Principles, Patterns, and Practice (1st edition). Pearson Education.

Garg, Vijay K. (2004). Concurrent and Distributed Computing in Java. John Wiley and Sons.

Garlan, D. and Le Metayer, D. (eds.) (1997). Coordination Languages and Models. Proceedings of the 2nd International Conference, Coordination ’97, LNCS 1282, Berlin: Springer-Verlag.

Gelernter, D. (1985). Generative communication in Linda. ACM Transactions on Programming Languages and Systems 7, 1 (January), 80 – 112.

Giannakopoulou, D., Magee, J.N. and Kramer, J. (1999). Checking Progress in Concurrent Systems. 7th ACM SIGSOFT Symposium on the Foundations of Software Engineering/7th European Software Engineering Conference (FSE/ESEC ’99), Toulouse, Springer-Verlag, 511 – 528.

Giannakopoulou, Dimitra and Lerda, Flavio (2002). From states to transitions: improving translation of LTL formulae to B üuchi automata. FORTE 2002, 308 – 326.

Giannakopoulou, D. and Magee, J. (2003). Fluent Model Checking for Event-Based Systems. Proceedings of the 4th joint meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE 2003), Helsinki, Finland (September).

Goldberg, A. and Robson, D. (1983). Smalltalk-80. Addison-Wesley.

Gomaa, H. (1993). Software Design Methods for Concurrent and Real-Time Systems. Reading, MA: Addison-Wesley.

Gribomont, P. and Wolper, P. (1989). Temporal logic. In A.Thayse (ed.) From Modal Logic to Deductive Databases. John Wiley and Sons.

Harel, D. (1987). Statecharts: a visual formalism for complex systems. Science of Computer Programming 8 (July), 231 – 274.

Harel, D., Lachover, H., Naamad, A., Pnueli, A., Politi, M., Sherman, R., Shtull-Trauring, A. and Trakhtenbrot, M. (1990). STATEMATE: a working environment for the development of complex reactive systems. IEEE Transactions on Software Engineering SE-16, 4 (April), 403 – 414.

Harel, D. and Kugler, H. (2000). Synthesizing State-Based Object Systems from LSC Specifications. 5th International Conference on Implementation and Application of Automata (CIAA’2000), Springer-Verlag.

Harel, D. and Marelly, R. (2003). Come, Let’s Play: Scenario-Based Programming Using LSCs and the Play-Engine. Springer-Verlag.

Havelund, K. and Pressburger, T. (2000). Model checking Java programs using Java PathFinder. International Journal on Software Tools for Technology Transfer 2, 4, 366 – 381.

Henzinger, T.A., Jhala, R., Majumdar, R. and Sutre, G. (2003). Software Verification with Blast. Proceedings of the Tenth International Workshop on Model Checking of Software (SPIN), LNCS 2648, Berlin: Springer-Verlag, 235 – 239.

Hoare, C.A.R. (1969). An axiomatic basis of computer programming. Communications of the ACM 12, 10, 576 – 580.

Hoare, C.A.R. (1974). Monitors: an operating system structuring concept. Communications of the ACM 17, 10 (October), 549 – 557.

Hoare, C.A.R. (1978). Communicating sequential processes. Communications of the ACM 21, 8 (August), 666 – 677.

Hoare, C.A.R. (1985). Communicating Sequential Processes. Prentice-Hall International Series in Computer Science.

Holt, R.C. (1983). Concurrent Euclid, The UNIX System, and Tunis. Reading, MA: Addison-Wesley.

Holt, R.C. and Cordy, J.R. (1988). The Turing programming language. Communications of the ACM 31, 12 (December), 1410 – 1423.

Holzmann, G.J. (1991). Design and Validation of Computer Protocols. Englewood Cliffs, NJ: Prentice-Hall International.

Holzmann, G.J. (1997). The model checker SPIN. IEEE Transactions on Software Engineering SE-23, 5 (May), 279 – 295.

Holzmann, G.J. and Smith, M.H. (2002). An automated verification method for distributed systems software based on model extraction. IEEE Transactions on Software Engineering SE-28, 4, 364 – 377.

INMOS Ltd. (1988a). OCCAM 2 Reference Manual. Prentice-Hall International Series in Computer Science.

INMOS Ltd. (1988b). Transputer Reference Manual. Englewood Cliffs, NJ: Prentice-Hall International.

ISO/IEC (1988). LOTOS: Formal description technique based on the temporal ordering of observational behaviour. International Standard 9074. Geneva: International Organization for Standardization – Information Processing Systems – Open Systems Interconnection.

ITU (1996). Message Sequence Charts (MSC’96). Recommendation Z.120. Telecommunication Standardisation Sector (ITU).

Jacquet, Jean-Marie and Picco, Gian Pietro (eds.) (2005). Coordination Models and Languages. 7th International Conference, COORDINATION 2005, Namur, Belgium, Proceedings, LNCS 3454, Berlin: Springer-Verlag.

Joseph, M. (ed.) (1996). Real-Time Systems: Specification, Verification and Analysis. Prentice-Hall International Series in Computer Science.

Kanellakis, P.C. and Smolka, S.A. (1990). CCS expressions, finite state processes, and three problems of equivalence. Information and Computation 86, 1 (May), 43 – 68.

Kleiman, S., Shah, D. and Smaalders, B. (1996). Programming with Threads. Upper Saddle River, NJ: SunSoft Press, Prentice-Hall.

Koskimies, K., Männistö, T., Systä, T. and Tuonmi, J. (1998). Automated support for modeling OO software. IEEE Software 15, 87 – 94.

Kramer, J. and Cunningham, R.J. (1979). Invariants for Specifications. Proceedings of 4th IEEE International Conference on Software Engineering (ICSE ‘79), Munich, 183 – 193.

Kramer, J. and Magee, J. (1998). Analysing dynamic change in distributed software architectures. IEE Proceedings – Software 145, 5 (October), 146 – 154.

Lamport, L. (1977). Proving the correctness of multiprocess programs. IEEE Transactions on Software Engineering SE-3, 2 (March), 125 – 143.

Lamport, L. (1980). “Sometime” is Sometimes “Not Never”: On the Temporal Logic of Programs. Proceedings of the 7th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Las Vegas, 174 – 185.

Lampson, B.W. and Redell, D.D. (1980). Experience with processes and monitors in Mesa. Communications of the ACM 23, 2 (February), 105 – 117.

Lea, Doug (1999). Concurrent Programming in Java™: Design Principles and Patterns (2nd edition). Addison-Wesley.

Lehman, D. and Rabin, M.O. (1981). A Symmetric and Fully Distributed Solution to the Dining Philosophers Problem. Proceedings of the 8th ACM Symposium on Principles of Programming Languages, January, 133 – 138.

Letier, E., Kramer, J., Magee, J. and Uchitel, S. (2005). Fluent Temporal Logic for Discrete-Time Event-Based Models. The Joint 10th European Software Engineering Conference and the 13th ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC-FSE 2005), Lisbon, Portugal (September), 70 – 79.

Leveson, N.G. and Turner, C.S. (1993). An investigation of the Therac-25 accidents. IEEE Computer 26, 7 (July), 18 – 41.

Lister, A. (1977). The problem of nested monitor calls. Operating Systems Review 11, 3 (July), 5–7.

Lynch, N.A. (1996). Distributed Algorithms. San Francisco, CA: Morgan Kaufmann.

McCarthy, J. (1963). Towards a Mathematical Science of Computation. IFIP Congress 62, 21 – 28.

Magee, J.N., Dulay, N. and Kramer, J. (1994). Regis: a constructive development environment for distributed programs. Distributed Systems Engineering Journal 1, 5, Special Issue on Configurable Distributed Systems, 304 – 312.

Magee, J.N., Dulay, N., Eisenbach, S. and Kramer, J. (1995). Specifying Distributed Software Architectures. Proceedings of 5th European Software Engineering Conference (ESEC ’95), Sitges (September), LNCS 989, Berlin: Springer-Verlag, 137 – 153.

Magee, J.N., Kramer, J. and Giannakopoulou, D. (1997). Analysing the Behaviour of Distributed Software Architectures: A Case Study. Proceedings of 5th IEEE Workshop on Future Trends in Distributed Computing Systems (FTDCS’97), Tunisia (October), 240 – 247.

Magee, J., Pryce, N., Giannakopoulou, D. and Kramer, J. (2000). Graphical Animation of Behaviour Models. Proceedings of 22nd IEEE/ACM International Conference on Software Engineering (ICSE-2000), Limerick, Ireland, 499 – 508.

Milner, R. (1989). Communication and Concurrency. Prentice-Hall International Series in Computer Science.

Milner, R., Parrow, J. and Walker, D. (1992). A calculus of mobile processes, I and II. Information and Computation 100, 1, 1 – 77.

Morris, F.L. and Jones, C.B. (1984). An early program proof by Alan Turing. Annals of the History of Computing 6, 2, 139 – 143.

Peterson, G.L. (1981). Myths about the mutual exclusion problem. Information Processing Letters 12, 3 (June), 115 – 116.

Peterson, J.L. (1981). Petri Net Theory and the Modeling of Systems. Englewood Cliffs, NJ: Prentice-Hall International.

Pnueli, A. (1977). The Temporal Logic of Programs. Proceedings of the 18th IEEE Symposium on the Foundations of Computer Science (FOCS-77), October/November, 46 – 57.

Reiss, S.P. (1990). Connecting tools using message passing in the Field Environment. IEEE Software 7, 4 (July), 57 – 66.

Roscoe, A.W. (1998). The Theory and Practice of Concurrency. Prentice-Hall International Series in Computer Science.

Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F. and Lorensen, W. (1991). Object-Oriented Modeling and Design. Englewood Cliffs, NJ: Prentice-Hall International.

Sandewall, E. (1995). Features and Fluents: The Representation of Knowledge about Dynamical Systems. Oxford University Press.

Schneider, Fred B. (1997). On Concurrent Programming (Graduate Texts in Computer Science). Springer-Verlag.

Selic, B., Gullekson, G. and Ward, P.T. (1994). Real-Time Object Oriented Modeling. NewYork: John Wiley and Sons.

Shaw, M. (1995). Comparing architectural design styles. IEEE Software 12, 6 (November), 27 – 41.

Shaw, M. and Garlan, D. (1996). Software Architecture: Perspectives on an Emerging Discipline. Englewood Cliffs, NJ: Prentice-Hall International.

Sloman, M.S. (ed.) (1994). Network and Distributed Systems Management. Addison-Wesley.

Swartout, W. and Balzer, R. (1982). On the inevitable intertwining of specification and implementation. Communications of the ACM 25, 7 (July), 438 – 440.

Turing, A. (1949). Checking a large routine. In the Report of a Conference on High Speed Automatic Calculating Machines, pp. 67 – 69.

Uchitel, S., Kramer, J. and Magee, J. (2003). Synthesis of behavioral models from scenarios. IEEE Transactions on Software Engineering SE-29, 2 (February), 99 – 115.

Uchitel, S., Kramer, J. and Magee, J. (2004). Incremental elaboration of scenario-based specifications and behaviour models using implied scenarios. ACM Transactions on Software Engineering and Methodology (TOSEM) 13, 1 (January), 37 – 85.

Vardi, M. (2001). Branching vs. Linear Time: Final Showdown. Proceedings of the 7th International Conference on Tools and Algorithms for the Construction and Analysis of Systems, LNCS 2031, Berlin: Springer-Verlag, 1 – 22.

Welsh, J. and Bustard, D.W. (1979). Pascal-Plus: another language for modular multiprogramming. Software: Practice and Experience 11, 947 – 957.

Whittle, J. and Schumann, J. (2000). Generating Statechart Designs from Scenarios. Proceedings of 22nd IEEE/ACM International Conference on Software Engineering (ICSE-2000), Limerick, Ireland, 314 – 323.

Wirth, N. (1977). Modula: a language for modular multiprogramming. Software: Practice and Experience 7, 3 – 35.




Concurrency(c) State Models & Java Programs
Concurrency: State Models and Java Programs
ISBN: 0470093552
EAN: 2147483647
Year: 2004
Pages: 162

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net