Environment-Based Design of Software: an Agile Software Design Method.
Masters thesis, Concordia Institute for Information Systems Engineering.
- Accepted Version
The Environment-Based Design of Software (EBD-S) is a design method, representing the application of the Environment-Based Design (EBD) to agile software development. It compliments contemporary agile software development methods – Scrum and Feature-Driven Development (FDD) – by providing a light-weight and flexible framework for the architecture and design documentation, formalized design concept generation and effective system evolution control. Under the EBD-S umbrella, software requirements are categorized as functional, leading to the design of the system, and quality requirements, reflected in software architecture. EBD-S uses the component-bus-system-property approach for conflict identification and capturing the proto-architecture of the system in a graph structure. The design concept generation stage relies on a two-phase matrix-based problem decomposition approach, adjusted for non-binary dependency analysis, and using the heuristic partitioning analysis to find better design solutions. The change control mechanism of EBD-S permits effective monitoring and control of the software architecture evolution through the agile development cycle. The integration of EBD-S to the real-world Scrum development processes is demonstrated on the example of Telecom Expense Management software development. EBD-S application resulted in 25% project time saving due to more accurate estimations, higher code quality and lower error rate.
References:Abrahamsson, P., Salo, O., Ronkainen, J., & Warsta, J. (2002). Agile software development methods: Review and analysis. VTT Publications(478).
Beck, K. (2001). Manifesto for Agile Software Development. Retrieved 03 15, 2011, from Agile Manifesto: http://agilemanifesto.org/
Brandozzi, M., & Perry, D. (2001). Transforming Goal-Oriented Requirement Specifications into Architecture Prescriptions. Proceedings STRAW'01 (pp. 54-61). ICSE 2001.
Butler, M., Jones, C., Romanovsky, A., & Troubitsyna, E. (2006). Rigorous Development of Complex Fault-Tolerant Systems. Springer, Lecture Notes in Computer Science, Vol. 4157.
Chen, L., & Zeng, Y. (2009). Automatic generation of UML diagrams from product requirement requirements described by natural language. The 2009 ASME International Design Engineering Technical Conferences (IDETC) and Computers and Information in Engineering Conference. San Diego.
Chen, L., Ding, Z., & Li, S. (2005). A Formal Two-Phase Method for Decomposition of Complex Design Problems. ASME Journal of Mechanical Design, Vol. 127, 184-195.
Chen, Z., & Zeng, Y. (2006). Classification of Product Requirements Based on Product Environment. Concurrent Engineering Research and Applications: an International Journal, Vol. 14(No. 3), 219-230.
Chen, Z., Yao, S., Lin, J., Zeng, Y., & Eberlein, A. (2007). Formalisation of product requirements: from natural language descriptions to formal specifications. International Journal of Manufacturing Research, Vol. 2(No. 3), 362-387.
Chung, L., Nixon, B., Yu, E., & Mylopoulos, J. (2000). Non-Functional Requirements in Software Engineering. Proceedings of the Second IEEE International Symposium on Requirements Engineering (pp. 132-139). IEEE.
Cockburn, A., & Highsmith, J. (2001). Agile Software Development: The Business of Innovation. IEEE Computer, Sept.(9), 120-127.
Coplien, J. O. (1999). Multi-paradigm design for C++. Boston, MA: Addison-Wesley Longman Publishing Co.
Dorst, K., & Cross, N. (2001). Creativity in the design process: co-evolution of problem solution. Design Studies, Vol. 22(Nr. 5), 425-437.
Dyba, T., & Dingsøyr, T. (2008). Empirical studies of agile software development: A systematic review. Information and Software Technology, Vol. 50(9), 833-859.
Egyed, A., & Grunbacher, P. (2002). Automating Requirements Traceability: Beyond the Record & Replay Paradigm. Proceedings. ASE 2002. 17th IEEE International Conference on: Automated Software Engineering (pp. 163-171). Edinburgh: IEEE.
Fielden, G. (1975). Engineering design. London: British Standards Institution.
Klein, M. (1991). Supporting conflict resolution in cooperative design systems. IEEE Transactions on Systems, Man and Cybernetics, Vol. 21(Issue 6), 1379-1390.
Lan, C., & Ramesh, B. (2008). Agile Requirements Engineering Practices: An Empirical Study. IEEE Software, Vol. 25(Issue 1), 60-67.
Li, S. (2010). Extensions of the Two-Phase Method for Decomposition of Matrix-based Design Systems. ASME Journal of Mechanical Design, Vol. 132, 061003.
Medvidovic, N., & Taylor, R. (2002). A Classification and Comparison Framework for Software Architecture Description Languages. IEEE Transactions on Software Engineering, Vol. 26(Issue 1), 70–93.
Medvidovic, N., Egyed, A., & Grunbacher, P. (2003). Stemming Architectural Erosion by Coupling Architectural Discovery and Recovery. Second International SofTware Requirements to Architectures Workshop (pp. 61-69). Portland, OR: ICSE.
Medvidovic, N., Rosenblum, D., & Taylor, R. (1999). A Language and Environment for Architecture-Based Software Development and Evolution. Proceedings of the 1999 International Conference on Software Engineering, (pp. 44-53). Los Angeles, CA.
Miller, G. (2001). The Characteristics of Agile Software Processes. The 39th International Conference of Object-Oriented Languages and Systems, (pp. 03-85). Santa Barbara, CA.
Nagel, E. (1961). The Structure of Science: Problems in the Logic of Scientific Explanation. Hackett Publishing Company, Inc.
Nandhakumar, J., & Avison, D. (1999). The Fiction of Methodological Development: A Field Study of Information Systems Development. Information Technology & People, Vol. 12(Issue 2), 176-191.
Nerur, S., Mahapatra, R., & Mangalaraj, G. (2005). Challenges of Migrating to Agile Methodologies. Communications of the ACM - Adaptive complex enterprises, Vol. 48(Issue 5), 73-87.
Neward, T. (2010). Multiparadigmatic .NET, Part 2. Retrieved 11 05, 2010, from msdn.microsoft.com: http://msdn.microsoft.com/en-us/magazine/gg232770.aspx
Nuseibeh, B. (2001). Weaving Together Requirements and Architectures. IEEE Computer, Vol. 34(Issue 3), 115-117.
Nuseibeh, B., & Easterbrook, S. (2000). Requirements Engineering: A Roadmap. Proceedings on the Conference on The Future of Software Engineering (pp. 34-46). New York: ACM.
Paetsch, F., Eberlein, A., & Maurer, F. (2003). Requirements Engineering and Agile Software Development. Enabling Technologies: Infrastructure for Collaborative Enterprises, 2003. WET ICE 2003., (pp. 308-313).
Pahl, G., & Beitz, W. (1988). Engineering Design: A systematic approach. Springer.
Perry, D., & Wolf, A. (1992). Foundations for the Study of Software Architectures. ACM SIGSOFT Software Engineering Notes, Vol. 17(Issue 4), 40-52.
Peters, J., & Ramanna, S. (2003). Towards a Software Change Classification System: A Rough Set Approach. Software Quality Journal, Vol. 11(Issue 2), 121-147.
Pimmler, T., & Eppinger, S. (1994). Integration Analysis of Product Decompositions. ASME Design Theory and Methodology Conference. Minneapolis, MN.
Radice, R., Roth, N., O’Hara, A. J., & Ciarfella, W. (1985). A Programming Process Architecture. IBM Systems Journal , Vol. 24(Issue 2), 79–90.
Robertson, S., & Robertson, J. (2007). Mastering the Requirements Process (2nd ed.). Addison-Wesley Professional.
Shaw, M., & Garlan, D. (1996). Software Architecture: Perspectives of an Emerging Discipline. Prentice Hall.
Simon, H. (1996). The Sciences of the Artificial (3rd ed.). The MIT Press.
Steward, D. (1981). The Design Structure System: A Method for Managing the Design of Complex Systems. IEEE Transactions on Engineering Management, Vol. 28, 71-74.
Suh, N. (1990). The Principles of Design. Oxford University Press.
Tomiyama, T., Gu, P., Jin, Y., Lutters, D., Kind, C., & Kimura, E. (2009). Design methodologies: Industrial and educational applications. CIRP Annals - Manufacturing Technology, Vol. 58(Issue 2), 543-565.
Truex, D. (2000). Amethodical systems development: The deferred meaning of systems development methods. Accounting, Management and Information Technologies, Vol. 10(Issue 1), 53-79.
Ulman, D. G. (1995). Taxonomy for Classifying Engineering Decision Problems and Support Systems. Artificial Intelligence for Engineering Design, Analysis and Manufacturing, Vol. 9, pp. 427-438.
Walls, Widmeyer, & Sawy. (1992). Building an Information System Design Theory for Vigilant EIS. Information Systems Research, Vol. 3(No. 1), 36-59.
Wang, M., & Zeng, Y. (2008). Asking the right questions to elicit product requirements. 22(4), 283-293.
Wiegers, K. (2003). Software Requirements, 2nd Edition. Microsoft Press.
Yan, B., & Zeng, Y. (2009). The structure of design conflicts. The 12th World Conference on Integrated Design & Process Technology. Alabama.
Yoshikawa, H. (1981). General Design Theory and a CAD System. Proceeding os the IFIP Working Group 5.2 Working Conference (pp. 35-58). Amsterdam: IFIP.
Zeng, Y. (2002). Axiomatic Theory of Design Modeling. Transactions of the SDPS: Journal of Integrated Design and Process Science, Vol. 6(No. 3), 1-28.
Zeng, Y. (2004). Environment-Based formulation of design problem. Transactions of the SDPS: Journal of Integrated Design and Process Science, Vol. 8(No. 4), 45-63.
Zeng, Y., & Cheng, G. (1991). On the logic of design. Design Studies, Vol. 12(No. 3), 137-141.
Zeng, Y., & Gu, P. (1999). A science-based approach to product design theory Part I: Formulation and formalization of design process. Robotics and Computer-Integrated Manufacturing, Vol. 15(No. 4), 331-339.
Zeng, Y., & Gu, P. (1999). A science-based approach to product design theory Part II: Formulation of design requirements and products. Robotics and Computer-Integrated Manufacturing, Vol. 15(No. 4), 341-352.
Zeng, Y., & Gu, P. (2001). An Environment Decomposition-Based Approach to Design Concept Generation. Interlnal Conference on Engineering Design, (pp. 525-532).
Zeng, Y., & Jianliang, J. (1996). Computational model for design. Proc. SPIE, 2644, 638.
All items in Spectrum are protected by copyright, with all rights reserved. The use of items is governed by Spectrum's terms of access
Repository Staff Only: item control page