AcmeStudio 2.1 User Manual. http://www-2.cs.cmu.edu/˜acme/Manual/AcmeStudio-2.1.htm

Akkanen, J., Kiss, A. and Nurminen J. K. (2002), “Evolution of a software component - experiences with a network editor component”, In Proceedings of the Sixth European Conference on Software Maintenance and Reengineering (CSMR), pp 119–125.

Aldrich, J., Chambers, C. and Notkin, D. (2002), “Archjava: Connecting software architecture to implementation,” In Proceedings of the 24th International Conference on Software Engineering, pp 187–197.

Alonso, G., Casati, F., Kuno, H. and Machiraju, V. (2004), “Web Services: Concepts, Architectures and Applications”, Springer-Verlag.

Alves, C. and Finkelstein, A. (2002), “Challenges in COTS decision-making: a goal-driven requirements engineering perspective”, In Proceedings of the 14th international Conference on Software Engineering and Knowledge Engineering (Ischia, Italy, July 15 - 19, 2002). SEKE '02, vol. 27. ACM, New York, NY, pp 789-794. DOI= http://doi.acm.org/10.1145/568760.568894

Alves, C. and Finkelstein, A. (2003), “Investigating conflicts in COTS decision-making”, International Journal of Software Engineering, 13 (5). pp. 1-21. ISSN 02181940.

Andreas, P. and Jakob S. (2008), “A Comparative Analysis of State-of-the-Art Component Frameworks for the Java Programming Language”, informatikpraktikum I, SS 08.

Arlat, J., Aguera, M., Amat, L., Crouzet, Y., Fabre, J., Laprie, J., Martins, E. and Powell, D. (1990), “ Fault Injection for Dependability Validation: A Methodology and Some Applications”, IEEE Trans. Softw. Eng. 16, 2 (Feb. 1990), pp. 166-182. DOI= http://dx.doi.org/10.1109/32.44380

Asklund, U., Bendix, L., Christensen, H. B. and Magnusson, B. (1999), “The Unified Extensional Versioning Model”, In Proceedings of the 9th international Symposium on System Configuration Management (September 05 - 07, 1999). J. Estublier, Ed. Lecture Notes in Computer Science, vol. 1675. Springer-Verlag, London, pp. 100-122.

Asklund, U., Bendix, L., Christensen, H. B. and Magnusson, B. (1999), “The Unified Extensional Versioning Model”, In Proceedings of the 9th international Symposium on System Configuration Management (September 05 - 07, 1999). J. Estublier, Ed. Lecture Notes in Computer Science, vol. 1675. Springer-Verlag, London, pp. 100-122.

Assman, U. (2000), “A component model for invasive composition”, Position paper at the ECOOP 2000 workshop on Aspects and Dimensions of Concerns,Cannes France.

Avizienis, A. (1985), “The N-version Approach to Fault Tolerant Systems”, IEEE TSE, pp. 1491-1501.

[AGS] Aegis 4.24, http://aegis.sourceforge.net,

[ADLa] Architecture Description Language,

http://en.wikipedia.org/wiki/ Architecture_description_language

[ADLb] Using Architecture Description Languages to improve Software Quality and Correctness, http://www.itl.nist.gov/div897/ctg/adl/adl_info.html

[AUM] ArgoUML, http://argouml.tigris.org/

References

238

[APP] Apple Computer Inc. (1995), Open Doc. User Manual. http://opendoc.apple.com

[AXC] ActiveX Controls, http://msdn.microsoft.com/en-us/library/aa751968.aspx

Bailey, Edward C. (2000), “Maximum RPM, Taking the Red Hat Package Manager to the Limit”, Red Hat, Inc., 2000, Online: http://www.rpm.org/max-rpm.

Basili, V. R. and Caldiera, G. (1991), “Identifying and Qualifying Reusable Software Components,” IEEE Computer, Vol. 24, Issue 2, pp 61-70.

Basili, V. R. and Rombach, H.D. (1991), “Support for Comprehensive Reuse,” Software Engineering Journal, Vol.6, pp. 301-318.

Batory, D. and Kim, W. (1985), “Modelling concepts for VLSI CAD objects”, ACM Transactions on Database Systems, Vol. 10, Issue 3, pp. 322-346.

Beech, D. and Mahbod, B. (1988), "Generalized Version Control in an Object-Oriented database", IEEE Conference on Data Engineering, Los Angeles, CA.

Beugnard, A., Jezequel, J. M., Plouzeau, N. and Watkins, D. (1999), “Making Components Contract Aware”, Computer 32, pp 38-45.

Ben Collins Sussman, Brian W. Fitzpatrick, C. Michael Pilato (2004), “ Version Control with Subversion” For Subversion 1.3 (book compiled from Revision 2393), Published (TBA), California, USA, First Release 2002, O’Reilly Media.

Belkhatir, N. and Estublier, J. (1987), “Experience with a data base of programs”, Proceedings of the ACM SIGSOFT-SIGPLAN Symposium on Practical Software Development Environments. SIGPLAN Not. 22, 1 (Jan. 1987), pp 84-91. DOI= http://doi.acm.org/10.1145/390012.24219

Belguidoum, M. and Dagnat, F. (2007), “Dependency Management in Software Component Deployment”, Electron. Notes Theor. Comput. Sci.182 (Jun. 2007), pp 17-32. DOI=http://dx.doi.org/10.1016/j.entcs.2006.09.029.

Berliner, B. (1990), “CVS II: Parallelizing Software Development”, In USENIX 1990, pp 341–352.

Bianchi, A., Caivano, D., Conradi, R., Jaccheri, L., Torchiano, M. and Visaggio, G. (2003), “COTS products characterization: proposal and empirical assessment”, Proc. Empirical Methods and Studies in Software Eng., LNCS 2765, Orlando, Florida, USA.

Bialek, R. P. (2002), “The architecture of a dynamically updatable component-based system”, In Proceedings of the 26th international Computer Software and Applications Conference on Prolonging Software Life: Development and Redevelopment COMPSAC. IEEE Computer Society, Washington, DC, 1012-1016.

Boegh, J. (2006), “Certifying Software Component Attributes”, IEEE Software, pp 74-81.

Boegh, J. (1999), “Quality Evaluation of Software Product,” Software Quality Professionals, Vol. 1, No. 2, pp 26-37.

Boehm, V.R. (2000), “Spiral Development: Experience, Principles and Refinements,” Special Report CMU/SEI-2000-SR-008, Software Engineering Institute, Carneige Mellon University, 2000.

Bosch, J. (1995), "Abstract Object State in Real-Time Control", In Proc. of the 3rd Workshop on Algorithms and Architectures for Real Time Control, Ostend, Belgium, pp. 111-130.

References

239

Booch, G. (1987), Software Components with Ada: Structures, Tools, and Subsystems, Benjamin-Cummings, Redwood City, CA.

Bott, F. and Ratcliffe, M. (1992), “Reuse and design”, Chapman & Hall, London, pp. 35-51.

Brada, P. (2003), Specification-Based Component Substitutability and Revision Identification, Ph.D. Dissertation, Charles University in Prague.

Brereton, P., Linkman, S., Thomas, N., Begh, J. and Panfilis, S. D. (2002), “Software Components—Enabling a Mass Market”, Proc. Int’l Workshop Software Tech. and Eng. Practice (STEP) 2002, IEEE CS Press, pp. 169.

Brown, A.W. and Wallnau, K.C. (1996), “Engineering of Component-Based Systems”, In Proceedings of 2nd IEEE International Conference of Engineering of Complex Computer Systems (ICECCS’96), pp. 414-422.

Brown, A. W. (1998), An Overview of CBD, Steering Software.

Brown, A.W. (2000), Large –Scale Component-Based Development, Upper Saddle River, NJ: Prentice Hall.

Brown, A.W. and Wallnau K.C., (1998), “An Examination of the Current State of CBSE: A Report on the ICSE Workshop on CBSE”, held in conjunction with 20th International Conference on Software Engineering, Kyoto, Japan.

Brown, D. J. and Runge, K. (2000), “Library interface versioning in solaris and linux,” in Proceedings of the 4th Annual Linux Showcase and Conference, Atlanta, Georgia, USA, pp. 10–14.

Burns A. and Davies G., (1993), Concurrent Programming, Addison Wesley.

[BIT] BitKeeper, www.bitkeeper.com

Candrlic S., Pavlic M. and Poscic P. (2007), “A Comparison and the Desirable features of Version Control Tools”, In Proceedings of the ITI 2007 29th Int. Conf. on Information Technology Interfaces, Cavtat, Crotia, pp. 121-126.

Carney, D.J., Morris, E.J. and Place, P.R.H. (2003), “Identifying commercial off-the-shelf (COTS) product risks: the COTS usage risk evaluation”, Carnegie Mellon Software Engineering Institute (SEI), CMU/ SEI-2003-TR-023, Sept. 2003.

Carvallo, J., Franch, X., Quer, C. and Torchiano, M. (2004), “Characterization of a taxonomy for business applications and the relationship among them”, Proc. Third Int. Conf. COTS-Based Software Systems (ICCBSS’04), LNCS 2959, 2004, pp. 221–231.

Casanova, M., Straeten, R.V.D. and Jonckers, V. (2003), “Supporting evolution in component based development using component libraries”, Proc. Seventh European Conf. on Software Maintenance and Re-engineering (CSRM), pp. 123–133.

Caruso, M. and Sciore, E. (1988), “Meta-functions and contexts in an object-oriented database language”, Proceedings of the ACM-SIGMOD Conference, Chicago.

Cechich, A., Requile-Romanczuk A., Aguirre, J., and Luzuriaga, J.M. (2006), “Trends on COTS component identification”. Proc. Fifth Int. Conf. Commercial-Off-the-Shelf (COTS)-Based Software Systems (ICCBSS’06), IEEE Computer Society.

References

240

Cechich, A., Piattini, M. and Vallecillo, A. (2003), “Assessing component based systems, Component based software quality”, LNCS 2693, pp. 1–20.

Cheesman, J. and Daniels, J. (2001), UML Components, A Simple Process for Specifying Component-Based Software, Addison-Wesley, 2001.

Choi, Y., Kwon, O. and Shin, G. (2002), “An Approach to Composition of EJB Components Using C2 Style,” Proc. 28th Euromicro Conf. (Euromicro ’02), pp. 40-46.

Chung, L. and Cooper, K. (2002), “Knowledge based COTS aware requirements engineering approach”, Proc. 14th Int. Conf. Software Eng. Knowledge Eng., (ACM Press), pp. 175–182.

Chirinos, L., Losavio, L. and Boegh J, (2005), “Characterizing a Data Model for Software Measurement,” J. Systems and Software, vol. 74, no. 2, pp. 207–226.

Christensen, H.B. (1998), “Experiences with architectural software configuration management in Ragnarok,” In Proceedings of SCM8 Workshop, ECOOP 1998. Springer Verlag.

Christiansson, B., Jakobsson, L. and Crnkovic, I. (2002), “CBD Process,” Building Reliable Component-Based Software Systems, I. Crnkovic and M. Larsson, eds., pp. 89-113, Artech House.

Clark, J., Clarke, C., Panfilis, S.D., Granatella, G., Predonzani, P., Sillitti, A., Succi, G. and Vernazza, T. (2004), “Selecting components in large COTS repositories”, J. Syst. Softw., 73, pp. 323–331.

Clark, A. and Pradhan, D.K. (1995), “Fault Injection: A Method for Validating Computer-System Dependability”, Computer, June 1995, pp. 47-56.

Clements, P.C. (1995), “From Subroutines to Subsystems: Component Based Software Development,” American Programmer, Vol. 8, No. 11.

Clements P.C. (1996), “A Survey of Architecture Description Languages”, Proc. Eighth Int’l Workshop Software Specification and Design (IWSSD ’96), pp. 16-25.

Clifford, J. and Croker, A. (1987), “The historical relation data model (HRDM) and algebra based on lifespans”, Proceedings of the Thirteenth IEEE Data Engineering Conference, Los Angeles.

Coleman D., Arnold P., Bodoff S., Dollin C., Gilchrist H., Hayes F. and Jeremaes, P. (1994), Object- Oriented Development, The Fusion Method, Prentice-Hall.

Conardi, R. and Westfechtel, B. (1998), “Version Models for Software Configuration Management”, ACM Computing Surveys, Vol. 30, No. 2.

Cohen, E., Soni, D., Gluecker, R., Hasling, W., Schwanke, R. and Wagner, M. (1988), “Version management in Gypsy”, Proceedings of the ACM SIGSOFT-SIGPLAN Symposium on Practical Software Development Environments, Boston.

Cook, S. and Daniels, J. (1994), Designing Object Systems, Prentice-Hall.

Cook, J. E. and Dage, J. A. (1999), "Highly Reliable Upgrading of Components", In Proceedings of 21st International Conference on Software Engineering, Los Angeles, pp. 203-212.

Cormen, T. H., Leiserson, C. E., Rivest, R. L. (1990), Introduction to Algorithms, (1st ed.), MIT Press and McGraw-Hill. ISBN 0-262-03141-8.

References

241

Crnkovic, I. (1991), Large Scale Software System Management, Ph.D Thesis, Department of Electrical Engineering, University of Zagreb.

Crnkovic, I., Larsson, M. and Lau, K. K. (1999), “Component Configuration Management for Frameworks”, http://www.cs.man.ac.uk/~kung-kiu/pub/wsac99.pdf

Crelier, R. (1994), Separate compilation and module extension, Ph.D dissertation, Swiss Federal Institute of Technology.

Crnkovic, I. and Larsson, M. (2000), “A Case Study: Demands on Component-Based Development”, Proc. 22nd Int. Conf. Software Engineering, Limerick, Ireland, ACM Press.

Crnkovic, I. et al., (editors), ( 2001), 4th ICSE Workshop on Component-Based Software Engineering: Component Certification and System Prediction, Software Engineering Notes, Vol. 26, No. 6.

Crnkovic, I. and Larsson, M. (2002), “Challenges of component based development’, J. Syst. Software, 61, (3), pp. 201–212.

[CCP] Cope Co-op, Peer-to-peer Version Control for Distributed Development, Reliable Software, http://www.relisoft.com/Co_op/

[CLE] Rational ClearCase, www.ibm.com/software/awdtools/clearcase,

http://www-2000.ibm.com/software/in/awdtools/clearcase/index.html

[CON] Continuus Software Corporation, “Continuus Software brings integrated configuration management environment to Microsoft Visual Studio’97,” http://www.accessmylibrary.com/article-1g1-19245691

[COMa] Microsoft COM, http://www.microsoft.com/com, http://www.microsoft.com/net/ http://msdn.microsoft.com/library

[COMb] COM+ (Component Services), http://msdn.microsoft.com/en-us/library/ms685978(VS.85).aspx

[CORa] CORBA Component Model (CCM), https://www.ibm.com/developerworks/webservices/library/co-cjct6/

[CORb] OMG, CORBA, http://www.omg.org/corba

CVS, 2009, CVS- Concurrent Version Control System V1.12.12.1: Overview, http://ximbiot.com/cvs/wiki/CVS

[CVSa] CVS-Concurrent Version Control System, http://www.cvshome.org

[CVSb] CVS-Concurrent Version Control System, http://www.nongnu.org/cvs/

[CVSc] TortoiseCVS, www.tortoisecvs.org, Initial release Dec., 2004.

[CVSd] CvsGui, www.wincvs.org

Daniel, R. and Richard, W. (2001), “Traditional, Iterative, and Component-Based Development: A Social Analysis of Software Development Paradigms”, Information Technology and Management, Volume 2, pp. 53-70.

References

242

David, T. and Andrew H. (2006), Pragmatic Version Control Using CVS, The Pragmatic starter kit Volume 1.

Demillo, R.A, Lipton, R.J. and Sayward, F.G. (1978), “Hints on Test Data Selection: Help for the Practicing Programmer,” Computer, Apr. 1978, pp. 34-41.

DeLine, R. (2001), “Avoiding packaging mismatch with flexible packaging”, IEEE Transactions on Software Engineering, 27(2): pp 124–143.

DeMichiel, L. and Keith, M. (2006), Enterprise JavaBeans, Version 3.0, Sun Microsystems.

D’Souza, D. and Wills, A. C. (1998), Objects, Components and Frameworks: The Catalysis Approach, Reading, MA: Addison-Wesley.

Dietrich, S.W., Patil, R., Sundermier, A. and Urban, S.D. (2006), “Component adaptation for event-based application integration using active rules”, J. Syst. Softw., 79, (12), pp. 1725–1734.

Dittrich, K. and Lorie, R. (1988), “Version support for engineering database systems”, IEEE Transactions on Software Engineering 14(4), pp. 429-437.

Dolenc, M. (2004), “Developing extendible component-oriented finite element software”, Advances in Engineering Software 35, 703-714.

Dogru, A. and Tanik, M. (2003), “A Process Model for Component-Oriented Software Engineering”, IEEE Software, pp. 34-41.

[DCV] Distributed Concurrent Version System, http://en.wikipedia.org/wiki/Distributed_Concurrent_Versions_System

[DPW] Dependency Walker, www.dependencywalker.com

[DVC] DVCS adoption is soaring among open source projects, http://arstechnica.com/open-source/news/2009

Eide, E. (2002), “Manage your software with java product versioning specification – an introduction to component versioning with java,” Java World, Tech. Rep., Sept. 2002.

Enselme, D., Florin, G. and Legond-Aubry, F. (2003), “Design by contracts: Analysis of hidden dependencies in component based applications”, In Journal of Object Technology, vol. 3, no. 4, April 2004, Special issue: TOOLS USA 2003, pp. 23-45, http://www.jot.fm/issues/issue_2004_04/article2

Eric, S. Raymond (2003), The Art of Unix Programming, Thyrsus Enterprises. http://www.faqs.org/docs/artu/ch15s05.html

Estublier, J. (2000), “Software Configuration Management: A Roadmap”, In International Conference on Software Engineering (ICSE), The Future of Software Engineering, Limerick, Ireland, pp. 279-289.

Eve, J. and Kurki-Suonio, R. (1977), “On computing the transitive closure of a relation”, Acta-Informatica, volume 8, issue 4.

[ECP] Eclipse Foundation: Eclipse. http://www.eclipse.org

[EUM] EclipseUML, http://www.omondo.com/.

References

243

Floyd, Robert W. (1962), “Algorithm 97: Shortest Path”, Communications of the ACM 5 (6): 345. doi:10.1145/367766.368168.

Fowler, M. and Scott, K. (1997), UML Distilled-Applying the Standard Object Modelling Language, Reading, MA: Addison-Wesley.

Frederic, P. Miller, Agnes, F. Vandome and John McBrewster (2009), Java (Software Platform), Alphascript Publishing.

Frost, S. & Allen, P. (1998), Tackling the Key Issues in CBD. Select Software Tools.

Gamma E., Helm R., Johnson R. and Vlissidies, J. (1995), Design Patterns, Elements of Reusable Object-Oriented Software, Addison-Wesley.

Gao, J., Espinoza, R. and He, J. (2005), “Testing coverage analysis for software component validation”, Proc. 29th Annual Int. Computer Software and Application Conf. (COMPSAC’05), Edinburgh, UK, pp. 463–470.

Gao, J., Gopinathan, D., Mai, Q. and He, J. (2006), “A systematic regression testing method and tool for software components”, 30th Annual Int. Comp. Software and Application Conference (COMPSAC’06), Chicago, USA, pp. 455–466.

Gaile E. Kaiser and Nico Habermann (1983), “An environment for system version control”, In Proceedings of 26th IEEE Computer Society Conference, San Francisco, CA, IEEE Computer Society Press.

Gardler, R. and Mehandjiev, N. (2002), “Supporting component-based software evolution”, In International Conference NetObjectDays on Objects, Components, Architectures, Services, and Applications for a Networked World, pp 103–120.

Garlan, D., Allen R. and Ockerbloom J. (1995), “Architectural Mismatch: Why Reuse is so Hard”, IEEE Software, volume 12, issue 6.

Gergic, J. (2003), “Towards a Versioning Model for Component-based Software Assembly”, In Proceedings of the international Conference on Software Maintenance (September 22 - 26, 2003), ICSM, IEEE Computer Society, Washington, DC, 138.

Gill, N. S. and Balkishan (2008), “Dependency and interaction oriented complexity metrics of component-based systems”, SIGSOFT Softw. Eng. Notes Volume 33 Issue 2 (Mar. 2008),

Glassy, L. (2006), “Using version control to observe student software development processes”, Journal of computing Sciences in Colleges, volume 21, issue 3, pp. 99-106.

Grechanik, M., Batory, D. and Perry, D. E. (2002), “Integrating and reusing GUI-driven application”, 7th International Conference on Software Reuse (ICSR-7), pp 1–16, http://www.cs.utexas.edu/users/gmark/Publications.html

Greenwood, R.M., Warboys, B.C. and Sa, J. (1996), “Co-operating evolving components: a rigorous approach to evolving large software systems”, Proc. 18th Int. Conf. on Software Engineering, IEEE Computer Society, pp. 428–437.

Green, R. (2000), “Documentation Meets Version Control: An Automated Backup System for HTML-Based Help”, IEEE, pp 541-548.

References

244

Griss, M. L. and Kessler, R. R. (2003), “Achieving the promise of reuse with agent components”, Lecture Notes in Computer Science, 2603:139–147.

[GIT] Git, http://www.git-scm.com

[GMM] The GNU Make Manual, http://www.gnu.org/software/make/manual/html_node/index.html

Hafedh, M., Fatma, M. and Ali, M. (1995), “Reusing software: Issues and research directions,” IEEE Transactions on Software Engineering, 21(6), pp 528-562.

Harmon, P. (1998), “Components, Component development strategies”. Cutter Information Corp.

Heineman G.T. and Councill W.T., (2001), editors. Component-Based Software Engineering: Putting the Pieces Together. Addison-Wesley.

Helm, R., Holland, I. M., and Gangopadhyay, D. (1990), “Contracts: specifying behavioral compositions in object-oriented systems”, SIGPLAN Not. 25, 10 (Oct. 1990), 169-180. DOI= http://doi.acm.org/10.1145/97946.97967

Hicks, D. L. (2003), “Towards Multi-Granular Versioning Support for Collaborative Design Applications”, In Proceedings of 8th International Conference on Computer Supported Cooperative Work in Design, IEEE, pp. 108-112.

Hoek, A. v. d., Hall, R. S., Heimbigner, D., and Wolf, A. L. (1997), "Software Release Management", In Proceedings of 6th European Software Engineering Conference, Lecture Notes on Computer Science, nr 1301, Springer.

Holland, I. (1992), “Specifying Reusable Components Using Contracts”, Proc. ECOOP, Utrecht, The Netherlands, Springer.

Hornstein, J., and Edler, H. (2002), “Test reuse in CBSE using built-in tests”, Proc. Workshop on Composing Systems from Components and Component-Based Software Engineering, Sweden, pp. 1-4.

Inoue, K., Yokomori, R., Fujiwara, H., Yamamoto, T., Matsushita, M., and Kusumoto, S. (2003), “Component rank: relative significance rank for software component search”, Proc. 25th Int. Conf. Softw. Eng., IEEE Computer Society, pp. 14–24.

Ivica Crnkovic and Magnus Larsson (2002), editors, Building Reliable Component-Based Software Systems, Artech House, Boston, London.

ISO/IEC 9126-1: (2001): Information Technology—Software Product Quality—Part 1: Quality Model, Int’l Organization for Standardization.

ISO/IEC 17011: (2004): Conformity Assessment—General Requirements for Accreditation Bodies Accrediting Conformity Assessment Bodies, Int’l Organization for Standardization.

ISO/IEC 17025: (1999): General Requirements for the Competence of Testing and Calibration Laboratories, Int’l Organization for Standardization.

ISO/IEC 25051: (2006): Software Engineering—Software Product Quality Requireents and Evaluation (SQUARE) — Requirements for Quality of Commercial Off-the-shelf (COTS) Software Product and Instructions for Testing, Int’l Organization for Standardization.

References

245

ISO/IEC 15408: (1999): Information Technology—Security Techniques—Evaluation Criteria for IT Security, Int’l Organization for Standardization.

IEC 61508 (1998): Functional Safety of Electrical/Electronic/ Programmable Electronic Safety Related Systems, Int’l Electrotechnical Commission.

ISO International Standard ISO/WD121199, ISO/WD121199-V4 (2001): Software Engineering –software product evaluation- Requirements for quality of commercial off-the shelf software products (COTS) and instructions for testing.

[IEEE] IEEE Recommended Practice on the Selection and Evaluation of CASE Tools (1994), P1209.

Jacky Estublier and Jean - Marie favre (2000), “Component Models and Technology”, Artech House, Boston. London, www.artechhouse.com, pp. 57-86.

Jacobson, I., Booch, G. and Rambaugh, J. (1999), The United Software Development Process, Reading, MA, Addison-Wesley-Longman.

Jain, H., Chalimeda, N., Ivaturi, N., and Reddy, B. (2001), “Business component identification – a formal approach”, Proc. Fifth IEEE Int. Enterprise Distributed Object Computing Conf., EDOC ’01, pp. 183–187.

Jain, H., Vitharana, P., and Zahedi, F. (2003), “An assessment model for requirements identification in component-based software development”, SIGMIS Database, Vol. 34, Issue 4, pp. 48-63. DOI= http://doi.acm.org/10.1145/957758.957765

Jalote, P. (1994): Fault Tolerance in Distributed Systems, Prentice Hall.

Janaki Ram. D., Sreekanth, M. and Ananda Rao, A., (2000), “Version Management in Unified Modeling Language”, Proceedings of 6th International Conference on Object Oriented Information Systems (OOIS 2000), London, pp. 238-252.

Janssens, N., Michiels, S., Mahieu, T. and Verbaeten, P. (2003), “Towards transparent hot-swapping support for producer-consumer components”, In Proceedings of Second International Workshop on Unanticipated Software Evolution (USE), pp. 9-16.

Jeffrey R. Shapiro (2002), The Complete Reference: Visual Basic.NET, McGraw-Hill.

Jilani, L., and Desharnais, J. (2001), “Defining and applying measure of distance between specifications”, IEEE Transactions on Software Engineering, 27, (8), pp. 673–703.

Johnson, R.E. (1997), “Frameworks = (Components + Patterns),” Communications of the ACM, Vol. 40, No. 10.

Johnson, R.E. (2001), “Documenting Frameworks Using Patterns”, In Proc. OOPSLA, New York, ACM Press.

John R. (1994), “OpenDoc, IBM and Apple’s pitfall for mega-applications”, Scientific American, pp. 130-131.

John S. Quarterman and Susanne Wilhelm, (1993), UNIX, POSIX, and Open System, Addison-Wesley.

Jonge, M. de (2002), “Source tree composition”, In Proceedings of the 7th International Conference on Software Reuse: Methods, Techniques, and Tools, Springer-Verlag, pp. 17–32.

References

246

Junrong, S., Xi, S., Gang, H., Wenpin, J., Yanchun, S. and Hong, M. (2005), “Towards a Unified Formal Model for Supporting Mechanisms of Dynamic Component Update”, In Proceedings of ESEC-FSE’05, September 5–9, 2005, Lisbon, Portugal, pp. 80-89.

[JAHa] JavaBeans Architecture: BDK Download. Sun Microsystems, http://java.sun.com/products/javabeans/software/bdk_download.html, 2003.

[JAHb] The Bean Builder, Sun Microsystems, https://bean-builder.dev. java.net/, 2007.

[JAVA] Sun Microsystems, “JavaBeans 1.01 Specification”, http://java.sun.com/beans

[J2EE] Java 2 Platform, Enterprise Edition Sun Microsystems, 2007, http://java.sun.com/j2ee/.

[JUD] Jude, http://objectclub.esm.co.jp/Jude/

Karsten Wolke (2007), Higher Availability of Services in Heterogeneous Distributed Systems, PhD Thesis, Leicester (GB), October 2007.

Katz, R. and Lehman, T. (1984), “Database support for versions and alternatives of large design files”, Proceedings of the IEEE Transactions on Software Engineering, 10(2), pp.191-200.

Katz, R., Chang, E. and Bhateja, R. (1986), “Version modelling concepts for computer-aided design databases”, Proceedings of the ACM-SIGMOD Conference, Washington D.C., pp. 379-386. DOI= http://doi.acm.org/10.1145/16856.16891

Katz, R., (1990), “Toward a unified framework for version modelling in engineering databases”, ACM Computing Surveys, 22(4), pp. 375-408.

Kaur, P. and Singh, H. (2008), “Automated Versioning Mechanism in Component-Based Systems”, CSI Communications, Vol. No. 32, Issue 6, Sept. 2008, pp .21-28.

Khan, K.M. and Han, J. (2002), “Composing security-aware software”, IEEE Software, 19(1), Jan.-Feb., 2002, pp. 34-41.

Kienle, H. M. and Muller, H. A. (2007), “A Lightweight Taxonomy to Characterize Component-Based Systems”, In Proceedings of the Sixth international IEEE Conference on Commercial-off-the-Shelf (Cots)-Based Software Systems (February 26 - March 02, 2007), ICCBSS, IEEE Computer Society, Washington, DC, 192-204. DOI= http://dx.doi.org/10.1109/ICCBSS.2007.2

Kon, F. and Campbell, R.H. (2000), “Dependency management in component-based distributed systems”, Concurrency, IEEE, Volume 8, Issue 1, Jan.-March 2000, pp. 26 – 36.

Kontio, J., Chen, S.-F., Limperos, K., Tesoriero, R., Caldiera, G., and Deutsch, M. (1995), “A COTS selection method and experience of its use”, Proc. 20th Annual Software Engineering Workshop, Greenbelt, Maryland, 1995.

Korel, B. (1999), “Black-box understanding of COTS components”, Proc. Seventh Int. Workshop on Program Comprehension, Pittsburgh, PA, USA, IEEE Computer Society, pp. 92.

Kumar, B. (2002), Component security, white paper, 2002.

[KON] Konesa, http://www.canyonblue.com/

References

247

Larsson, M. (2000), “Applying Configuration Techniques to Component-Based Systems”, Ph.D. Thesis, Department of Computer Engineering, Malardalen University.

Larsson, M. and Crnkovic, I. (1999), “New challenges for configuration management”, In Proceedings of the SCM9 workshop, ECOOP 1999, LNCS 1675, Toulouse, France.

Larsson, M. and Crnkovic, I. (2000), “Component configuration management”. In Proceedings of the ECOOP Conference, Workshop on Component Oriented Programming, Nice, France.

Lau, K. K. and Ornaghi, M. (1999), “OOD Frameworks in Component-Based Software Development in Computational Logic”, Proc. LOPSTR’98, Lecture Notes in Computer Science, No. 1559, Berlin, Springer Verlag, pp.101-123.

Lau, K. K. and Wang, Z. (2006), “A Survey of Software Component Models”, 2nd edition, Preprint Series, School of Computer Science, University of Manchester, pp.1-58. http://www.cs.man.ac.uk/preprints/index.html

Lau, K. K. and Wang, Z. (2007), “Software Component Models”, IEEE Transactions on Software Engineeing, Vol. 33, No. 10, pp. 709-724.

Lau K.K., U. Vladyslav , V. Perla, W. Zheng (2006), “A Component Model for Separation of Control Flow from Computation in Component-based Systems”, Electronic Notes in Theoretical Computer Science, 163 (2006), 57-69. URL: www.elsevier.nl/locate/entcs

Lee, S.D., Yang, Y.J., Cho, F.S., Kim, S.D., and Rhew, S.Y. (1999), “COMO: a UML-based component development methodology”, In Proc. Sixth Asia Pacific Software Eng. Conf., pp. 54–61.

Lee, J.K., Jung, S.J., Kim, S.D., Jang, W.H., and Ham, D.H. (2001), “Component identification method with coupling and cohesion”, In Proc. Eighth Asia-Pacific Software Eng. Conf., pp. 79–86.

Lee, S.C., and Shirani, A.I. (2004), “A component based methodology for web application development”, Journal of System Software, 71, pp. 177 - 187.

Lea, D. and Marlowe, J. (1995), “Interface-Based Protocol Specification of Open Systems using PSL”, In Proc. of the ECOOP'95, Aarhus, Denmark, pp. 374-398.

Leavens G.T. and Sitaraman M, (2000), Foundations of component-based systems, Cambridge University Press.

Leonardo, M. and Mauro, P., (2005), “Technique for Verifying Component-Based Software”, Electronic Notes in Theoretical Computer Science, 116 (2005), 17-30. URL: www.elsevier.nl/locate/entcs

Levine, J. R. (1999), Linkers & Loaders. Morgan Kaufmann, September 1999, vol. one.

Leblang, D. and Chase, R. (1984), “Computer-aided software engineering in a distributed workstation environment”, Proceedings of the ACM SIGSOFT-SIGPLAN Symposium on Practical Sofflware Development Environments, Pittsburgh, PA.

Li, B., Zhou, Y., Wang, Y., and Mo, J. (2005), “Matrix-based component dependency representation and its applications in software quality assurance”, SIGPLAN Not. 40, 11, 29-36.

References

248

Liu Y.D., Smith S.F. (2006), “A Formal Framework for Component Deployment”, In Proceedings of OOPSLA’06, Portland, Oregon, USA, 2006, pp. 325-343.

Lindqvist, U. and Jonsson, E. (1998), “A map of security risks associated with using COTS” , IEEE Computer. 31(6), pp. 60-66.

Lindsay, P. and Traynor, O. (1998), “Supporting fine-grained traceability software development environments,” In Proceedings of Softw. Config. Management Workshop. Springer.

Louridas, P. (2006), “Version control”, Software, IEEE, volume 23, Issue 1, Pp 104 – 107.

Lumpe, M., Achermann, F. and Nierstrasz, O. (2000), “A Formal Language for Composition,” Foundations of Component Based Systems, G. Leavens and M. Sitaraman, eds., pp. 69-90, CambridgeUniv. Press.

MacDonald, Joshua P. (2004), “PRCS, the Project Revision Control System”, http://prcs.sourceforge.net/, (May 9, 2004), Retrieved 2008-12-12.

Ma, L., Wang, H. and Lu, Y. (2006), “The Design of Dependency Relationship Matrix to improve the Testability of Component-Based Software”, Proc. Of the 6th International Conference on Quality Software (QSIC’06), IEEE Computer Society Press, Los Alamitos CA, pp. 93-98.

Mason, M. (2006), Pragmatic Version Control Using Subversion, The Pragmatic starter kit- Volume 1, Shroff publications.

Mao, C., Zhang, J. and Lu, Y. (2007), “Using Dependence Matrix to Support Change Impact Analysis for CBS”, IEEE Fifth International conference on Computational Science and Applications, pp. 192-197, DOI 10.1109/ICCSA.2007.25.

Marvie, R., and Merle, P. (2001), “CORBA Component Model: Discussion and Use with open CCM”, Technical report Laboratoire d’Informatique fondamentale de Lille Universite des Sciences et Techniques de Lille, Lille, France.

Markus V. (2003), “ A Taxonomy for components”, In Journal of Object Technology, Vol. 2, No. 4, pp. 119-125.

Maurer, P. M. (2000), “Components: What if They Gave a Revolution and Nobody came?”, IEEE Computer, Vol. 33, Issue 6, pp. 28-34.

Maiden, N.A., and Ncube, C. (1998), “Acquiring COTS software selection requirements”, IEEE Software, 15, (2), pp. 46–56.

Mauth R. (1996), “A better foundation: development frameworks let you build an application with reusable objects”, BYTE 21(9):40IS 10-13, Sept. 96.

McDirmid, S. Flatt, M. and Hsieh, W. C. Jiazzi (2001), “New-age components for old-fashioned java”, In Proceedings of the 2001 ACM SIGPLAN Conference on Object-Oriented Programming,Systems, Languages & Applications (OOPSLA’01), pp. 211–222.

McIlroy D. (1968), “Mass-produced software components”, In P. Naur and B. Randell, editors, Proceedings of NATO Software Engineering Conference, pp. 138-155, Garmisch, Germany.

Meyer, B. (2003), “The grand challenge of trusted components”, In Proc. ICSE 2003, pp 660–667.

Meyer, B. (1992a), “Applying Design by Contracts”, IEEE Computer, Vol. 25, No. 10, pp 40-51.

References

249

Meyer, B. (1992b), “Eiffel: The Language”, Upper Saddle River, NJ: Prentice Hall.

Medvidovic, N., Oreizy, P. and Taylor, R.N. (1997), “Reuse of Off-the-Shelf Components in C2-Style Architectures”, ICSE ’97, Boston, MA.

Mezini, M. and Ostermann, K. (2002), “Integrating independent components with on-demand remodularization”, Proc. 17th ACM SIGPLAN Conf. Object-Oriented Programming, Systems, Languages, and Appl., 2002, (ACM Press), pp. 52–67.

Mili, R., Mili, A. and Mittermeir, R.T. (1997), “Storing and retrieving software components: a refinement based system”, IEEE Trans. Softw. Eng., 23, (7), pp. 445–460.

Mockus, A. (2009), “Amassing and indexing a large sample of version control systems: towards the census of public source code history”, IEEE, 2009, pp. 11-20.

Mohmood, S., Lai, R. and Kim, Y.S. (2007), “Survey of Component-based Software Development”, IET Software, Volume 1, No. 2, pp. 57-66.

Moller A., Akerholm M., Fredriksson J., and Nolin M. (2004), “Evaluation of component technologies with respect to industrial requirements”, 30th IEEE EUROMICRO Conference (EUROMICRO’04), pp. 56–63.

Morisio M. and Torchiano M. (2002), “Definition and classification of COTS: a proposal”, In J. Dean and A. Gravel, editors, 1st International Conference on COTS-Based Software Systems (ICCBSS’02), volume 2255 of Lecture Notes in Computer Science, Springer-Verlag, pp. 165–175.

Morris, J., Lee, G., Parker, K., Bundell, G. A., and Lam, C. P. (2001), “Software Component Certification”, IEEE Computer, Vol. 34, No. 9, 2001, pp. 30-36.

Musa J.D, Iannino A, and Okumoto K, (1987), Software Reliability Measurement Prediction Application, McGraw- Hill, New York.

Murta, L., Oliveira, H., Dantas, C., Lopes, L. G. and Werner, C. (2007), “Odyssey-SCM: An integrated software configuration management infrastructure for UML models”, Sci. Comput. Program. 65, (2007), pp. 249-274.

Murta, L., Correa, C., Prudencio, J. G. and Werner, C. (2008), “Towards Odyssey-VCS 2: Improvements over a UML-based Version Control System”, In CVSM’08, Leipzig, Germany, pp. 25-30.

Mukherjee, P., Leng, C., Terpstra, W.W., Schurr, A. (2008), “Peer-to-Peer Based Version Control”, in Parallel and Distributed Systems, 2008. ICPADS '08, 14th IEEE International Conference on 8-10 Dec. 2008, pp. 829 – 834, Melbourne, VIC.

[MCMa] Microsoft (1996), “The Component Object Model Specification”, Report v0.99, Microsoft Standards, Redmond, WA:

[MCMb] Microsoft, “The Component Object Model: A Technical Overview (MSDN)”, http://msdn.microsoft.com/en-us/library/ms809980.aspx

[MCV] Microsoft, MSDN Library, Component Versioning, http://msdn.microsoft.com/en-us/library/aa309506(VS.71).aspx

[MER] Mercurial, http://mercurial.selenic.com

References

250

[MTS] Microsoft Transaction Server, http://en.wikipedia.org/wiki/Microsoft_Transaction_Server, visited on 11th Jan., 2010.

[MWI] Microsoft Windows Installer, http://www.microsoft.com/.

Nguyen, T.N. and Munson, E.V. (2003), “The software concordance: a new software document management environment”, ACM Press, pp. 198–205.

Nguyen, T.N., Munson, E.V., Boyland, J.T. and Thao, C. (2004), “Molhado: Object-Oriented Architectural Software Configuration Management”, IEEE Computer Society. pp. 510.

Nguyen, T.N., Munson, E.V., Boyland, J.T. and Thao, C. (2005a), “Multi-level Configuration Management with Fine-grained Logical Units”, In Proceedings of 31st EUROMICRO Conference on Software Engineering and Advanced Applications (EUROMICRO-SEAA’05), pp. 248-257.

Nguyen, T.N., Munson, E.V., Boyland, J.T., Thao, C. (2005b), “An Infrastructure for Development of Object-Oriented, Multilevel Configuration Management Services”, In Proceedings of 27th International Conference on Software Engineering (ICSE 2005). ACM Press, pp. 215-224.

Nierstrasz, O., Gibbs, S., and Tsichritzis, D. (1992), “Component-oriented software development”, Communications of the ACM 35(9), pp. 160-165.

Nierstrasz, O. (1995), “Research Directions in Software Composition”, In Proceedings, Langages et Modèles à Objets, A. Napoli (Ed.), Nancy, pp. 193-204.

Ning, J.Q. (1997), “Component Based Software Engineering (CBSE)”, Proc. Fifth Int. Symp. on Assessment of Software Tools and Technologies, pp. 34–43.

Nico Habermann and David Notkin (1986), “Gandalf: Software development environments”, IEEE Transactions on Software Engineering, Vol. 12, Issue 12, pp.1117-1127.

Nistor, E. C., Erenkrantz, J. R., Hendrickson, S. A. and van der Hoek, A. (2005), “ArchEvol: versioning architectural-implementation relationships”, In Proceedings of the 12th international Workshop on Software Configuration Management (Lisbon, Portugal, September 05 - 06, 2005). SCM '05. ACM, New York, NY, 99-111.

[NETa] Microsoft .NET Framework (2009), http://en.wikipedia.org/wiki/NET_Framework, preview release 19-10-2009.

[NETb] .NET General, http://msdn.microsoft.com/en-us/library/aa137140.aspx

Oberleitner, J., Gschwind, T. and Jazayeri, M. (2003a), “The Vienna Component Framework: Enabling Composition Across Component Models”, In Proceedings of 25th International Conference on Software Engineering (ICSE’03), Portland, Oregon, pp 25--35,

Oberleitner, J. and Gschwind, T. (2003b), “Composing distributed components with the component workbench,” In Proceedings of Software Engineering and Middleware 2003, LNCS 2596, pp 102-114.

Oda, T. and Saeki, M. (2005), “Generative Technique of Version Control Systems for Software Diagrams”, In Proceedings of the 21st IEEE international Conference on Software Maintenance (September 25 - 30, 2005). ICSM. IEEE Computer Society, Washington, DC, 515-524. DOI= http://dx.doi.org/10.1109/ICSM.2005.49.

References

251

Ohst, D. and Kelter, U. (2002), “A fine-grained version and configuration model in analysis and design”, In Proceedings of International Conference on Software Maintenance, (ICSM’02), IEEE Computer Society.

Olafsson, A. and Bryan, D. (1996), “On the Need for ‘Required Interfaces’ of Components”, Proc. Special Issues in Object-Oriented Programming: Workshop Reader of the 10thEuroean Conference on Object-Oriented Programming, ECCOP ’96, Linz, Austria, Springer, pp. 159-165.

Ommering, R. Van (2002), “The Koala Component Model”, Building Reliable Component-Based Software systems, I. Crnkovic and M. Larsson, eds., pp. 223-236, Artech House.

Oussalah, C., Talens, G. and Giambiasi, N. (1992), “Version Management for the Modelling of Complex Systems”, CEMIT92, August 31- September 4, 1992, Tokyo.

Oussalah, C., Talens, G. and Colinas, M.F. (1993), “Concepts and methods for version modelling”, In Proceedings of EURO-DAC’93, Hamburg, Germany, pp. 332-337.

[OMG] Object Management Group, CORBA, http://www.omg.org/corba

[OSGI] OSGI Service Gateway Specification, Release 1.0, http://www.osgi.org

Paulk M. C., Curtis, B., Chrissis, M. B. and Weber C.V. (1993), “Capability Maturity Model for Software, version 1.1”, Technical Report CMU/SEI-93-TR-024, ESC-TR-93-177, Software Engineering Institute, Carnegie Mellon University, Pittsburgh, PA.

Pahl, C. (2003), “An ontology for software component matching”, Proc. Sixth Int. Conf. Fundamental Approaches to Softw. Eng., LNCS 2624, 2003, pp. 6–21.

Parrish, A., Dixon, B., and Cordes, D. (2001), “A conceptual foundation for component based software deployment”, J. Syst. Softw., 57, (3), pp. 193–200.

Peter H. Feiler (1991), “Configuration Management Models in Commercial Software Development Environments”, SEI Technical Report CMU/SEI−91−TR−7, March 1991.

Pfister, C. and Szyperski, C. (1998), “Why objects are not enough”, In Proceedings of the First Component User's Conference on Component-Based Software Engineering (Munich, Germany). T. Jell, Ed. Cambridge University Press, New York, NY, pp. 141-147.

Plasil, F., Balek, D. and Janecek R. (1998), “SOFA/DCUP: Architecture for Component Trading and Dynamic Updating”, Proc. Fourth Int’l Conf. Configurable Distributed Systems (ICCDS ’98), pp. 43-52.

Plaice, J. and Wadge, W. W. (1993), “A New Approach to Version Control”, IEEE Transactions on Software Engineering, Vol. 19, No. 3, pp. 268-276.

Pilato, M., (2004), Version Control with Subversion, O’Reilly & Associates, Inc., Sebastopol, CA, USA.

Pressman, R.S. (2000), Software Engineering-A Practitioner’s Approach, McGraw-Hill International Ltd., New York.

Poston, R.M., and Sexton, M.P. (1992), “Evaluating and Selecting Testing Tools”, IEEE Software,V9, #3, pp 33-42.

References

252

[PER] Perforce, The Fast Software Configuration Management System, http://msdn.microsoft.com/

[PRC] Project Revision Control System, http://prcs..sourceforge.net

[POS] Poseidon for UML, http://www.gentleware.com/.

Ray, I., and Zhang, J. (2007), “Towards a new standard for allowing concurrency and ensuring consistency in revision control systems”, Computer Standards and Interfaces, 29 (2007), pp. 355-364.

Raje, R. R., Auguston, M., Bryant, B. R., Olson, A. M. and Burt, C. (2001), “A unified approach for the integration of distributed heterogeneous software components”, In Proceedings of the Monterey Workshop on Engineering Automation for Software Intensive System Integration, pp. 109–119.

Rausch, A. (2000), “Software evolution in componentware using requirements/assurances contracts”, Proc. 22nd Int. Conf. on Software Eng., ACM Press, pp. 147–156.

Ramakrishnan, R. and Janaki Ram, D. (1996), “Modeling Design Versions”, Proceedings of 22nd International Conference on VLDB, Mumbai(Bombay), India, pp. 556-566.

Rakic, M. and Medvidovic, N. (2001), “Increasing the confidence in off-the-shelf components: a software connector-based approach,” in Proceedings of the 2001 symposium on Software reusability, pp. 11–18.

Reis, C. R. and Fortes, R. P. M. (2004), “VersionWeb: a tool for Open Source Software development support”, In Proceedings of the WebMedia & LA-Web 2004 Joint Conference 10th Brazilian Symposium on Multimedia and the Web 2nd Latin American Web Congress (LA-Webmedia’04).

Reichenberger, C. (1989), “Orthogonal Version Management”, SIGSOFT Softw. Eng. Notes, Vol. 17, No. 7, 137-140.

Reichenberger, C. (1993), “VOODOO: A Tool for Orthogonal Version Management”, Proceedings of the 4th International Workshop on Software Configuration Management, Baltimore, Maryland, USA.

Reichenberger, C. (1996), “Keeping Things Straight, Orthogonally”, MacTech Magazine Vol. 12, No. 6. http://www.mactech.com/articles/mactech/Vol.12/12.06/VoodooReview/index.html

Rege, K. (1999), “Design Patterns for Component-Oriented Development”, In Proceedings of 25th EUROMICRO in the workshop on Software Process and Product Improvment, IEEE Computer Society. pp. 220-228.

Rine, D., Nada, N. and Jaber, K. (1999), “Using adapters to reduce interaction complexity in reusable component based software development”, Proc.1999 symp. on Software reusability, (ACM Press), pp. 37–43.

Robey, D. and Welke, R. (2001), “Traditional, Iterative, and Component-Based Development: A Social Analysis of Software Development Paradigms”, Information Technology and Management 2, Kulwer Academic Publishers, pp. 53-70.

Romanovsky, A. (1999), “Abstract object state and version recovery in N-version programming”, In Proceedings of Technology of Object-Oriented Languages and Systems, pp. 86-95, France.

References

253

Rogerson, D. (1997), Inside COM, Microsoft Press, ISBN 1-57231-349-8.

Rochkind M. J. (1975), “The Source Code Control System”, In IEEE transactions on Software Engineering SE-1:4, pp. 364-370.

Rolf Andreas Rasenack (2008), “Adaptation of Black-Box Software Components”, Annals Computer Sci. Series, 6th Tome, Ist Fasc., pp. 153-168.

Roman, E. (1999), Mastering Enterprise JavaBeans and the Java 2 Platform, Enterprise Edition, Wiley.

Ronan M. L., (2002), “Robocop: Robust open component based software architecture for configurable devices project. Initial specification”, ITEA PROJECT 00001 Deliverable, 2002.

Rho, J. and Wu, C. (1998), “An efficient version model of software diagrams”, In Proc. 5th Asia-Pacific Software Engineering Conf. (APSEC), 2-4 December 1998 in Taipei, Taiwan, ROC. IEEE Computer Society, pp. 236.

Ryman, A., Chinnici, R., Moreau, J-J and Weerawarana, S. (2007), “Web services description language (wsdl) version 2.0 Part 1: Core Language”, W3C Recommendation 26 June 2007.

[RAR] Rational Rose, http://www-6.ibm.com/jp/software/rational/.

[RCS] RCS-GNU Project-Free Software Foundation (FSF), www.gnu.org/software/rcs

Sametinger, J. (1997), Software Engineering with Reusable Components, Springer-Verlag, New York.

Sassi, S.B., Jilani, L.L. and Ghezala, H.H.B. (2003), “COTS Characterization Model in a COTS-Based Development Environment”, Proceedings of the Tenth Asia-Pacific Software Engineering Conference (APSEC’03), IEEE Computer Society, pp. 1-10.

Sciore, E. (1994), “Versioning and configuration management in an object-oriented data model”, The VLDB Journal 3, pp. 77-106.

Schumauch, C. H. (1994), “IS0 9000 for Software Developers”, ASQC Quality Press.

Sommerville, I. (2001), Software Engineering, Theory and Practice, Upper Saddle River, NJ: Prantice- Hall.

Spinellis D. and Szyperski C., (2004), “How is open source affecting software development?” IEEE Software, 21(1), pp. 28–33.

Stafford, J. A. and Wolf, A. L. (2001), “Architecture-level dependence analysis for software systems”, International Journal of Software Engineering and Knowledge Engineering, 11(4), pp. 431–453, August 2001.

Stuckenholz, A. (2005), “Component Evolution and Versioning: State of the art”, ACM SIGSOFT Software Engineering Notes, Volume 30, Number 1, pp. 1-13.

Siram, N. N. Raje, R. R. Olson, A. M. Bryant, B. R., Burt, C. C. and Auguston, M. (2002), “An architecture for the uniframe resource discovery service”, In Proceedings of the 3rd International Workshop on Software Engineering and Middleware 2002 (SEM 2002), pp. 22–38.

References

254

Szyperski, C., Gruntz, D. and Murer, S. (2008), Component Software: Beyond Object-Oriented Programming, Addison-Wesley Professional, Boston, First Edition 1997. ISBN 0-201-17888-5.

Shaw, M., DeLine, R., Klein, D. V., Ross, T. L., Young, D. M., and Zelesnik, G. (1995), “ Abstractions for Software Architecture and Tools to Support Them”, IEEE Trans. Softw. Eng. 21, 4 (Apr. 1995), pp. 314-335. DOI= http://dx.doi.org/10.1109/32.385970

Shaw, M. (1996), “Truth vs Knowledge: The Difference Between What a Component Does and What We Know It Does”, In Proceedings of the 8th international Workshop on Software Specification and Design (March 22 - 23, 1996). International Workshop on Software Specifications & Design. IEEE Computer Society, Washington, DC, 181.

Suvee, D., Vanderperren, W. and Jonckers, V. (2003), “JAsCo: an aspect oriented approach tailored for component based software development”, Proc. Second International Conf. on Aspect-Oriented Software Development, ACM Press, Boston, USA, pp. 21-29.

[SCC] GNU CSSC, http://cssc.sourceforge.net/

[SCM] Better SCM Initiative: Version Control System Comparison, 2009 http://better-scm.berlios.de/comparison/comparison.html

[SUB] Subversion, http://subversion.tigris.org

[SYN] Rational Synergy and Change Suite http://www-2000.ibm.com/software/rational/products/synergychangesuite/

Thomas, D. and Hunt, A. (2003), Version management with CVS, The Pragmatic Programmers. ISBN 0-9745140-0-4.

Thompson, S. M. (1997), “Configuration management - keeping it all together”, BT Technical Journal, Vol. 15, No 3, pp. 48-60.

Tran, V., Liu, D.-B., and Hummel, B. (1997), “Component based systems development: challenges and lessons learned”, Proc. Eighth IEEE Int. Workshop Software Technol. Eng. Practice, pp. 452–462

Tichy, W. F. (1985), “RCS- A System for Version Control”, Software: Practice & Experience, vol. 15, no. 7, pp 637-654.

Tichy, W. F. editor (1994), Configuration Management, Trends in Software series, Wiley, ISBN 0-471-94245-6.

[UMLa] IBM-Rational, Unified Modeling languages, UML resource centre, http://www-01.ibm.com/software/rational/uml/

[UMLb] Unified Modeling Language Superstructure, V2.1.2, (OMG UML), http://www.omg.org/docs/formal/07-11-01.pdf

[USP2001a] VOODOO Personal User Manual http://www.unisoftwareplus.com/products/voodoopersonal.html

[USP2001b] VOODOO Server User Manual http://www.unisoftwareplus.com/products/voodooserver.html

References

255

[VSS] Microsoft Visual Source Safe, http://msdn.microsoft.com/ssafe

Vandewoude, Y. and Berbers, Y. (2002), “Run-time evolution for embedded component-oriented systems”, In Proceedings of International Conference on Software Maintenance(ICSM), pp 242–245.

Vandewoude, Y., Rigole, P., Urting, D. and Berbers, Y. (2003), “Draco: An adaptive runtime environment for components”, Technical Report CW372, Department of Computer Science, Katholieke Universiteit Leuven, Belgium.

Vandewoude, Y. and Berbers, Y. (2005), “Fresco: Flexible and Reliable Evolution System for Components”, Electronic Notes in Theoretical Computer Science 127 (2005) 197-205.

Van Der Storm, T. (2005), “Continuous release and upgrade of component-based software”, Proc. of the 12th international Workshop on Software Configuration Management (Lisbon, Portugal, September 05 - 06, 2005). SCM '05. ACM, New York, pp. 43-57.

Vieira, M., Dins, M. and Richardson, D. J. (2001), “Describing Dependencies in Component Access Points”, Proceedings of the 4th Workshop on Component Based Software Engineering, 23rd International Conference on Software Engineering (ICSE'01, Toronto, Canada), pp.115-118.

Vieira, M. and Richardson, D. J. (2002a), “Classifying and dealing with dependencys in large component-based systems”, In Proceedings of the Fifteenth International Conference on Software & Systems Engineering & their Applications, pp. 1–10, Paris.

Vieira, M. and Richardson, D. J. (2002b), “Analyzing dependencies in large component-based systems”, In Proceedings of the 17th IEEE International Conference on Automated Software Engineering, Edingburgh, UK, pp. 23–27.

Visnovsky, S. (1999), Checking semantic compatibility of SOFA/DCUP components, Master’s thesis, Charles University, Faculty of Mathematics and Physics, Prague.

Voas, J. and Payne, J. (2000), “Dependability Certification of Software Components”, J. of Software Systems, Vol. 52, pp. 165-172.

Voas, M. Jeffrey (1998), “Certifying Off-the-Shelf Software Components”, IEEE Computer, June 1998, pp. 53-59.

[VSS] Microsoft Visual Source Safe Roadmap, http://msdn.microsoft.com/en-us/library/aa302175.aspx

Wallnau, K. C. (2000), Volume II: Technical Concepts of Component-Based Software Engineering, 2nd Edition, Technical Report CMU/SEI-2000-TR-008, ESC-TR-2000-007, Pittsburgh, pp. 1-52.

Wallnau, K. C. and Stafford, J. (2001), “Ensembles: Abstractions for a New Class of Design problem”, Proc. 27th Euromicro Conf., Warsaw, Poland, IEEE Computer Society. pp. 48-55.

Wallnau, K.C. (2004), “Software Component Certification: 10 Useful Distinctions”, CMU/SEI-2004-TN-031, Carnegie Mellon Software engineering Institute, Pitsburgh, pp. 1-20.

Warmer, J. and Kleppe, A. (2000), The Object Constraint Language, Reading, MA, Addison – Wesley.

References

256

Wagner, T. A. and Graham, S. L. (1995), “Integrating incremental analysis with version management”, In Proceedings of ESEC ‘95 - 5th European Software Engineering Conference. Sitges, Spain. 25-28 Sept. 1995, pp. 205–18, Berlin – Heidelberg - New York, Springer–Verlag.

Wagner, T. A. and Graham, S. L. (1997), “Efficient self-versioning documents”, In Proceedings IEEE COMPCON 97. Digest of Papers. San Jose, CA, USA. IEEE Comput. Soc. 23-26 Feb. 1997., pp. 62–67. IEEE Comput. Soc. Press, Los Alamitos, CA, USA.

Wegner, P. (1993), “Towards component-based software technology”, Technical Report No. CS-93-11, Brown University.

Wegner, P. (1996), “Foundations of interactive computing,” Technical Report No. CS-96-11, Brown University.

Westfechtel, B., Munch, B.P. and Conradi, R. (2001), “A Layered Architecture for Uniform Version Management”, IEEE Transactions on Software Engineering, Vol. 27, No. 12.

Whitehead, J. and Wiggins, M. (1998), “WEBDAV: IETF standard for collaborative authoring on the Web”, IEEE Internet Computing, pp. 34–40.

Wu, Y., Pan, D. and Chen, M. H. (2001), “Techniques for testing component-based software”, Proc. Seventh IEEE Int. Conf. on Engineering of Complex Computer Systems, pp. 186–189.

[W3C] W3C, Open Software Description Format, http://www.w3.org/TR/NOTE-OSD.html

Xia, Y., Ho, A.T.S., and Zhang, Y. (2000), “CIMO – component integration model”, Proc. Seventh Asia-Pacific Software Eng. Conf., pp. 344–348.

[XML] XML Metadata Interchange, http://www.omg.org/.

Yau, S.S., and Karim, F. (1999), “Integration of object-oriented software components for distributed application software development”, Proc. Seventh IEEE Workshop on Future Trends of Distributed Computing Systems, 1999, pp. 111–116.

Yajuan, P., Dai, P. and Mei-Hwa, C. (2005), “Slicing Component-Based Systems”, Proceedings of the 10th IEEE Conference of Engineering of Complex Computer Systems (ICECCS’05), June 2005, pp. 155 – 164.

YAFOOL, "Manuel d'utilisation ", SEMA Group, Mai, 1991.

Yourdon, E. (1989), Modern Structured Analysis, Prentice Hall.

Yakimovich, D., Bieman, J. M. and Basili, V. R. (1999), “Software architecture classification for estimating the cost of COTS integration”, 21st ACM/IEEE International Conference on Software Engineering (ICSE’99), pp. 296–302.

Zeller, A. and Snelting, G. (1995), “Handling version sets through feature logic”, In Proc. 5th European Software Engineering Conference (Sitges, Spain, Sept. 1995), W. Schäfer and P. Botella, Eds., vol. 989 of Lecture Notes in Computer Science, Springer-Verlag, pp. 191–204.

Zeller, A. (1995), “A unified version model for configuration management”, In Proc. 3rd ACM SIGSOFT Symposium on the Foundations of Software Engineering (Washington, DC, Oct. 1995), G. Kaiser, Ed., vol. 20 (4) of ACM Software Engineering Notes, ACM Press, pp. 151–160.

References

257

Zeller, A. (1997a), Configuration Management with Version Sets, PhD thesis, Technical University of Braunschweig, Germany.

Zeller, A. (1997b), “Versioning software systems through concept descriptions,” Computer Science Report 97-01, Technical University of Braunschweig, Germany.

Zaremski, A.M. and Wing, J.M. (1995), “Signature matching: a tool for using software libraries”, ACM Trans. Softw. Eng. Methodol., 4, (2), pp. 146–170.

Zaremski, A.M. and Wing, J.M. (1997), “Specification matching of software components”, ACM Trans. Softw. Eng. Methodol., 6, (4), pp. 333–369.

Zdonik, S. B. (1986), “Version management in an object-oriented database”, In An international Workshop on Advanced Programming Environments (Trondheim, Norway). R. Conradi, T. M. Didriksen, and D. H. Wanvik, Eds. Springer-Verlag, London, pp. 405-422.

Total Versioning Physical Workspace Intentional Versioning Version Set Preferences Defaults Version Space Variants Embedded Deltas V2 V3 V1 Software List