Skip to main content

From requirements to UML models and back: how automatic processing of text can support requirements engineering

Abstract

Software engineering is supposed to be a structured process, but manual tasks leave much leeway. Ideally, these tasks lie in the hands of skilled analysts and software engineers. This includes creating the textual specification of the envisioned system as well as creating models for the software engineers. Usually, there is quite a bit of erosion during the process due to requirement changes, implementation decisions, etc. To deliver the software as specified, textual requirements, models, and the actual software need to be synchronized. However, in practice, the cost of manually maintaining consistency is too high. Our requirements engineering feedback system automates the process of keeping textual specification and models consistent when the models change. To improve overall processing of natural language specifications, our approach finds flaws in natural language specifications. In addition to the already published workshop paper, we show how well our tools support even non-software-engineers in improving texts. The case studies show that we can speed up the process of creation texts with fewer flaws significantly.

This is a preview of subscription content, access via your institution.

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9

References

  • Abrial, J.-R., Börger, E., & Langmaack, H. (1996). The steam boiler case study: Competition of formal program specification and development methods. In Formal methods for industrial applications. Specifying and programming the steam-boiler control (pp. 1–12). Berlin: Springer. URL:http://citeseerx.ist.psu.edu/viewdoc/download.

  • Ackerman, A. F., Buchwald, L. S., & Lewski, F. H. (1989). Software inspections: An effective verification process. Software, IEEE, 6(3), 31–36, ISSN 0740-7459. doi:10.1109/52.28121.

  • Ambriola, V., & Gervasi, V. (2006). On the systematic analysis of natural language requirements with circe. Automated Software Engginiering, 13, 107–167, ISSN 0928-8910. doi:10.1007/s10515-006-5468-2. URL:http://portal.acm.org/citation.cfm?id=1107757.1107761.

  • Arkley, P., & Riddle, S. (2005). Overcoming the traceability benefit problem. In Proceedings of 13th IEEE International Requirements Engineering Conference (RE) (pp. 385–389). doi:10.1109/RE.2005.49.

  • Bajwa, I. S., & Choudhary, M. A. (2006). Natural language processing based automated system for UML diagrams generation. In The 18th Saudi National Computer Conference on computer science (NCC18). Riyadh: The Saudi Computer Society (SCS).

  • Berry, D. M. (2004). The inevitable pain of software development: Why there is no silver bullet. In M. Wirsing, A. Knapp, & S. Balsamo (Eds.), Proceedings of Monterey Workshop 2002: Radical Innovations of Software and Systems Engineering in the Future, LNCS 2941. Berlin: Springer.

  • Berry, D. M. (2008). In A. Bucchiarone, S. Gnesi, & G. Trentanni (Eds.), A new quality model for natural language requirements specifications. URL:http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.96.5268.

  • Berry, D. M., Kamsties, E., & Krieger, M. M. (2003). From contract drafting to software specification: Linguistic sources of ambiguity—a handbook. URL:http://se.uwaterloo.ca/~dberry/handbook/ambiguityHandbook.pdf.

  • Bohner, S. A., & Arnold, R. S. (Eds.). (1996). An introduction to software change impact analysis. In Software change impact analysis (pp. 1–26). Los Alamitos: IEEE Computer Society Press.

  • Briand, L. C., Labiche, Y., & O’Sullivan, L. (2003). Impact analysis and change management of uml models. Technical Report SCE-03-01, Carleton University.

  • Chantree, F., Nuseibeh, B., de Roeck, A., & Willis, A. (2006). Identifying nocuous ambiguities in natural language requirements. In RE ’06: Proceedings of the 14th IEEE International Requirements Engineering Conference (RE’06) (pp. 56–65). Washington, DC: IEEE Computer Society, ISBN 0-7695-2555-5. doi:10.1109/RE.2006.31.

  • Chaumun, M. A., Kabaili, H., Keller, R. K., & Lustman, F. (2002). A change impact model for changeability assessment in object-oriented software systems. Science of Computer Programming, 45(2–3), 155–174, ISSN 0167-6423. doi:10.1016/S0167-6423(02)00058-8

  • Chen, R. (2011). The old new thing. MSDN blogs. URL:http://blogs.msdn.com/b/oldnewthing/archive/2011/12/12/10246541.aspx.

  • Cheng, B. H. C., & Atlee, J. M. (2007). Research directions in requirements engineering. In Proceedingfs of Future of Software Engineering FOSE ’07. doi:10.1109/FOSE.2007.17, pp. 285–303.

  • Courtois, P.-J., & Parnas, D. L. (1993). Documentation for safety critical software. In ICSE ’93: Proceedings of the 15th international conference on Software Engineering (pp. 315–323). Los Alamitos, CA: IEEE Computer Society Press. ISBN 0-89791-588-7.

  • Daigle, L. (2004). WHOIS protocol specification. Internet. URL:http://www.ietf.org/rfc/rfc3912.txt. The Internet Engineering Task Force (IETF).

  • Davis, A., Overmyer, S., Jordan, K., Caruso, J., Dandashi, F., Dinh, A., Kincaid, G., Ledeboer, G., Reynolds, P., Sitaram, P., Ta, A., & Theofanos, M. (1993). Identifying and measuring quality in a software requirements specification. In Proceedings of the First International Software Metrics Symposium (pp. 141–152). ISBN 0-8186-3740-4. doi:10.1109/METRIC.1993.263792.

  • Dawson, L., & Swatman, P. A. (1999). The use of object-oriented models in requirements engineering: A field study. In ICIS (pp. 260–273). doi:10.1145/352925.352949.

  • Denger, C., Berry, D. M., & Kamsties, E. (2003). Higher quality requirements specifications through natural language patterns. In Proceedings of the IEEE International Conference on Software-Science, Technology & Engineering (SWSTE ’03) (p. 80). Washington, DC: IEEE Computer Society. ISBN 0-7695-2047-2. doi:10.1109/SWSTE.2003.1245428.

  • Derre, B. (2010). Rückkopplung von Softwaremodelländerungen in textuelle Spezifikationen. Master’s thesis. Karlsruhe: Karlsruhe Institute of Technology.

  • Deva Kumar, D., & Sanyal, R. (2008). Static UML model generator from analysis of requirements (SUGAR). In Advanced software engineering and its applications, 2008 (ASEA 2008) (pp. 77–84). doi:10.1109/ASEA.2008.25.

  • Deva Kumar, D., & Sanyal, R. (2009). An innovative approach for generating static UML models from natural language requirements. In Advances in Software Engineering, vol. 30 of Communications in Computer and Information Science, pp. 147–163. Berlin: Springer. ISBN 978-3-642-10241-7 (Print) 978-3-642-10242-4 (Online). doi:10.1007/978-3-642-10242-4_13.

  • Eclipse Modeling Framework Project. (2010). Eclipse modeling framework compare. URL:http://www.eclipse.org/emf/compare/. Last visited: 05/07/2012.

  • Fabbrini, F., Fusani, M., Gnesi, S., & Lami, G. (2001). The linguistic approach to the natural language requirements quality: Benefit of the use of an automatic tool. In SEW ’01: Proceedings of the 26th Annual NASA Goddard Software Engineering Workshop (p. 97). Washington, DC: IEEE Computer Society. ISBN 0-7695-1456-1.

  • Fagan, M. E. (1976). Design and code inspections to reduce errors in program development. IBM Systems Journal, 15(3), 182–211. doi:10.1109/ASEA.2008.25

    Article  Google Scholar 

  • Fantechi, A., Gnesi, S., Lami, G., & Maccari, A. (2002). Application of linguistic techniques for use case analysis. In Proceedings of the IEEE International Conference on Requirements Engineering, 2002 (pp. 157–164). ISSN 1090-705X. doi:10.1109/ICRE.2002.1048518.

  • Fillmore, C. J. (1969). Toward a modern theory of case. In D. A. Reibel, & S. A. Schane (Eds.), Modern studies in English (pp. 361–375). Englewood Cliffs: Prentice Hall.

  • Fliedl, G., Kop, C., & Mayr, H. C. (2004). Recent results of the NLRE (natural language based requirements engineering) project. EMISA Forum, 24(1), 24–25.

    Google Scholar 

  • Fuchs, N. E., Schwertel, U., & Schwitter, R. (1999). Attempto controlled English—not just another logic specification language. Lecture Notes in Computer Science, 1559, 1–20, ISSN 0302-9743. doi:10.1007/3-540-48958-4_1.

  • Gelhausen, T. (2010). Modellextraktion aus natürlichen Sprachen: Eine Methode zur systematischen Erstellung von Domänenmodellen. Ph.D. thesis. Karlsruhe: Karlsruhe Institute of Technology.

  • Gelhausen, T., Derre, B., & Gei,  R. (2008). Customizing grgen.net for model transformation. In Proceedings of GRaMoT ’08 (pp. 17–24). ACM. ISBN 978-1-60558-033-3. doi:10.1145/1402947.1402951.

  • Gelhausen, T., & Tichy, W. F. (2007). Thematic role based generation of UML models from real world requirements. In Proceedings of the ICSC 2007, (pp. 282–289). doi:10.1109/ICOSC.2007.4338360.

  • Glinz, M., Heymans, P., Persson, A., Sindre, G., Aurum, A., Madhavji, N. H., Paech, B., Regev, G., & Wieringa, R. (2009). Report on the working conference on requirements engineering: Foundation for software quality (REFSQ’09). ACM SIGSOFT Software Engineering Notes, 34(5), 40–45.

    Article  Google Scholar 

  • Han, J. (1997). Supporting impact analysis and change propagation in software engineering environments. In Proceedings of the 8th IEEE International Workshop on Software Technology and Engineering Practice (pp. 172–182). doi:10.1109/STEP.1997.615479.

  • Harmain, H. M., & Gaizauskas, R. J. (2000). CM-Builder: An automated NL-based CASE tool. In ASE (pp. 45–54). doi:10.1109/ASE.2000.873649.

  • Hasegawa, R., Kitamura, M., Kaiya, H., & Saeki, M. (2009). Extracting conceptual graphs from Japanese documents for software requirements modeling. In M. Kirchberg, & S. Link (Eds.), APCCM, vol. 96 of CRPIT (pp. 87–96). Australian Computer Society. ISBN 978-1-920682-77-4.

  • Havasi, C., Speer, R., & Alonso, J. B. (2007). ConceptNet 3: A flexible, multilingual semantic network for common sense knowledge. In Recent advances in natural language processing. Borovets, Bulgaria. URL:http://web.media.mit.edu/~jalonso/cnet3.pdf.

  • Heitmeyer, C. L., Jeffords, R. D., & Labaw, B. G. (1996). Automated consistency checking of requirements specifications. ACM Transactions on Software Engineering Methodology, 5(3), 231–261, ISSN 1049-331X. doi:10.1145/234426.234431.

    Google Scholar 

  • IEEE Computer Society. (1998). IEEE recommended practice for software requirements specifications. IEEE Standard 830-1998, pp. 1–40. doi:10.1109/IEEESTD.1998.88286.

  • Juristo, N., Moreno, A. M., & López, M. (2000). How to use linguistic instruments for object-oriented analysis. IEEE Software, 17(3), 80–89. doi:10.1109/52.896254.

    Article  Google Scholar 

  • Kaiya, H., & Saeki, M. (2005). Ontology based requirements analysis: Lightweight semantic processing approach. In Proceedings of Fifth International Conference on Quality Software (QSIC 2005) (pp. 223–230, 19–20). doi:10.1109/QSIC.2005.46.

  • Kaiya, H., & Saeki, M. (2006). Using domain ontology as domain knowledge for requirements elicitation. In Proceedings of the IEEE International Conference Requirements Engineering (pp. 189–198, 11–15). doi:10.1109/RE.2006.72.

  • Kamsties, E., Knethen, A. V., Philipps, J., & Schätz, B. (2001). An empirical investigation of the defect detection capabilities of requirements specification languages. In EMMSAD’01: Proceedings of the Sixth CAiSE/IFIP8.1 International Workshop on Evaluation of Modelling Methods in Systems Analysis and Design.

  • Kiyavitskaya, N., Zeni, N., Mich, L., & Berry, D. M. (2008). Requirements for tools for ambiguity identification and measurement in natural language requirements specifications. Requirements Engineering, 13(3), 207–239, ISSN 0947-3602. doi:10.1007/s00766-008-0063-7.

  • Konrad, S., & Cheng, B. H. C. (2005). Facilitating the construction of specification pattern-based properties. Requirements Engineering, IEEE International Conference on (pp. 329–338). doi:10.1109/RE.2005.29.

  • Körner, S. J., & Brumm, T. (2010). Natural language specification improvement with ontologies. International Journal of Semantic Computing (IJSC), 03, 445–470.

    Article  Google Scholar 

  • Körner, S. J., & Landhäußer, M. (2010). Semantic enriching of natural language texts with automatic thematic role annotation. In Proceedings of the Natural language processing and information systems, and 15th international conference on Applications of natural language to information systems, NLDB’10 (pp. 92–99). Berlin: Springer. ISBN 3-642-13880-2, 978-3-642-13880-5. http://dl.acm.org/citation.cfm?id=1894525.1894537.

  • Körner, S. J., Landhäußer, M., Gelhausen, T., & Derre, B. (2012). RECAA – the requirements engineering complete automation approach. URL:https://svn.ipd.uni-karlsruhe.de/trac/mx.

  • Kroha, P. (2000). Preprocessing of requirements specification. In M. T. Ibrahim, J. Küng, & N. Revell (Eds), Database and expert systems applications, vol. 1873 of Lecture Notes in Computer Science (pp. 675–684). Berlin: Springer. ISBN, 978-3-540-67978-3. doi:10.1007/3-540-44469-6_63.

  • Kroha, P., Gerber, P., & Rosenhainer, L. (2006). Towards generation of textual requirements descriptions from UML models. In Proceedings of the 9th International Conference Information Systems Implementation and Modelling ISIM2006 (pp. 31 – 38). ISIM.

  • Kung, D. C., Gao, J., Hsia, P., Wen, F., Toyoshima, Y., & Chen, C. (1994). Change impact identification in object oriented software maintenance. In Proceedings of the International Conference on Software Maintenance (pp. 202–211). doi:10.1109/ICSM.1994.336774.

  • Landhäußer, M., Körner, S. J., & Tichy, W. F. (2012). Synchronizing domain models with natural language specifications. In Proceedings of the Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE’2012). doi:10.1109/RAISE.2012.6227965.

  • Li, K., Dewar, R. G., & Pooley, R. J. (2005). Towards semi-automation in requirements elicitation: Mapping natural language and object-oriented concepts. In RE05 (pp. 5–7).

  • Liaskos, S., Lapouchnian, A., Yu, Y., Yu, E., & Mylopoulos, J. (2006). On goal-based variability acquisition and analysis. In Proceedings of the 14th IEEE International Requirements Engineering Conference, RE ’06 (pp. 76–85). Washington, DC: IEEE Computer Society. ISBN 0-7695-2555-5. doi:10.1109/RE.2006.45.

  • Liu, H., & Singh, P. (2004). ConceptNet—a practical commonsense reasoning tool-kit. BT Technology Journal, 22. URL:http://larifari.org/writing/BTTJ2004-ConceptNet.pdf.

  • Mala, G. S. A., & Uma, G. V. (2006). Automatic construction of object oriented design models [UML diagrams] from natural language requirements specification. In PRICAI(pp. 1155–1159). Guilin, China. doi:10.1007/11801603_152.

  • Meng, W. J., Rilling, J., Zhang, Y., Witte, R., & Charland, P. (2006). An ontological software comprehension process model. 3rd International Workshop on Metamodels, Schemas, Grammars, and Ontologies for Reverse Engineering (ATEM 2006). October 1st, Genoa, Italy.

  • Meziane, F., Athanasakis, N., & Ananiadou, S. (2008). Generating natural language specifications from UML class diagrams. Requirements Engineering, 13(1), 1–18. doi:10.1007/s00766-007-0054-0.

    Article  Google Scholar 

  • Mich, L., Franch, M., & Inverardi, P. (2004). Market research for requirements analysis using linguistic tools. Requirements Engineering, 9, 40–56, ISSN 0947-3602. doi:10.1007/s00766-003-0179-8.

  • Montes, A., Pacheco, H., Estrada, H., & Pastor, O. (2008). Conceptual model generation from requirements model: A natural language processing approach. In E. Kapetanios, V. Sugumaran, & M. Spiliopoulou (Eds.), NLDB, vol. 5039 of Lecture Notes in Computer Science (pp. 325–326). Berlin: Springer. ISBN 978-3-540-69857-9.

  • Moreno, A. M., & van de Riet, R. P. (1997). Justification of the equivalence between linguistic and conceptual patterns for the object model.

  • Natt och Dag, J., Gervasi, V., Brinkkemper, S., & Regnell, B. (2004). Speeding up requirements management in a product software company: Linking customer wishes to product requirements through linguistic engineering. In Proceedings of the Requirements Engineering Conference, 12th IEEE International, RE ’04 (pp. 283–294). Washington, DC: IEEE Computer Society. ISBN 0-7695-2174-6. doi:10.1109/RE.2004.47.

  • Natt och Dag, J., Regnell, B., Gervasi, V., & Brinkkemper, S. (2005). A linguistic-engineering approach to large-scale requirements management. Software, IEEE, 22(1), 32–39. doi:10.1109/MS.2005.1.

    Article  Google Scholar 

  • Niu, N., & Easterbrook, S. (2008). Extracting and modeling product line functional requirements. In Proceedings of the 2008 16th IEEE International Requirements Engineering Conference, RE ’08 (pp. 155–164). Washington, DC: IEEE Computer Society. ISBN 978-0-7695-3309-4. doi:10.1109/RE.2008.49.

  • Nuseibeh, B., & Easterbrook, S. (2000). Requirements engineering: A roadmap. In ICSE ’00: Proceedings of the Conference on The Future of Software Engineering (pp. 35–46). New York, NY: ACM Press. ISBN 1-58113-253-0. doi:10.1145/336512.336523.

  • Overmyer, S. P., Lavoie, B., & Rambow, O. (2001). Conceptual modeling through linguistic analysis using LIDA. In Proceedings of the ICSE ’01 (pp. 401–410). Washington, DC: IEEE Computer Society. ISBN 0-7695-1050-7.

  • Parnas, D. L. (1985). Software aspects of strategic defense systems. Communications of the ACM, 28(12), 1326–1335, ISSN 0001-0782. doi:10.1145/214956.214961.

  • Pease, A., & Murray, W. (2003). An english to logic translator for ontology-based knowledge representation languages. In Natural Language Processing and Knowledge Engineering. Proceedings of the 2003 International Conference on (pp. 777–783). doi:10.1109/NLPKE.2003.1276010.

  • Pisan, Y. (2000). Extending requirement specifications using analogy. In ICSE ’00: Proceedings of the 22nd international conference on Software engineering (pp. 70–76). New York, NY: ACM. ISBN 1-58113-206-9. doi:http://doi.acm.org/10.1145/337180.337190.

  • Reiter, E., & Dale, R. (2000). Building natural language generation systems. Natural language processing. Cambridge: Cambridge University Press. doi:10.2277/052102451X.

  • Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-oriented modeling and design. Upper Saddle River, NJ: Prentice-Hall, Inc. ISBN 0-13-629841-9.

  • Rupp, C., & die SOPHISTen (2006). Requirements-Engineering und Management (4th ed.). Munich: Carl Hanser Verlag. ISBN 3-446-40509-7.

  • Saeki, M. (2004). Ontology-based software development techniques. ERCIM News, 58, 14–15. URL:http://www.ercim.org/publication/Ercim_News/enw58/EN58.pdf.

  • Smith, R. L., Avrunin, G. S., Clarke, L. A., & Osterweil, L. J. (2002). Propel: An approach supporting property elucidation. In ICSE 2002: Proceedings of the 24rd International Conference on Software Engineering (pp. 11–21). ISBN 1-58113-472-X.

  • Volere. (2009). List of requirement engineering tools. URL:http://www.volere.co.uk/tools.htm.

  • Wiegers, K. E. (2003). Software requirements : Practical techniques for gathering and managing requirements throughout the product development cycle (2nd. ed.). Redmond, WA: Microsoft Press. ISBN 0-7356-1879-8; 978-0-7356-1879-4.

  • Wilson, W. M., Rosenberg, L. H., & Hyatt, L. E. (1997). Automated analysis of requirement specifications. In ICSE ’97: Proceedings of the 19th International Conference on Software Engineering (pp. 161–171). ISBN 0-89791-914-9.

  • Xing, Z., & Stroulia, E. (2005). Umldiff: An algorithm for object-oriented design differencing. In Proceedings of the 20th IEEE/ACM international Conference on Automated software engineering, ASE ’05 (pp. 54–65). New York, NY: ACM. ISBN 1-58113-993-4. doi:10.1145/1101908.1101919.

  • Yang, H., de Roeck, A., Gervasi, V., Willis, A., & Nuseibeh, B. (2010). Extending nocuous ambiguity analysis for anaphora in natural language requirements. In Proceedings of the 2010 18th IEEE International Requirements Engineering Conference, RE ’10 (pp. 25–34). Washington, DC: IEEE Computer Society. ISBN 978-0-7695-4162-4. doi:10.1109/RE.2010.14.

  • Zhang, Y., Witte, R., Rilling, J., & Haarslev, V. (2006). An ontology-based approach for traceability recovery. In 3rd International Workshop on Metamodels, Schemas, Grammars, and Ontologies for Reverse Engineering (ATEM 2006). Jean-Marie Favre Dragan Gasevic Ralf Lämmel Andreas Winter.

Download references

Acknowledgements

We would like to thank Alexander M. Turek, Bugra Derre, and Fatih Ok. Research on the RECAA/AUTOMODEL project is funded by legodo.com in cooperation with the Karlsruhe Institute of Technology (KIT), Germany.

Author information

Authors and Affiliations

Authors

Corresponding author

Correspondence to Mathias Landhäußer.

Appendix: Requirements specifications

Appendix: Requirements specifications

The following texts were used during the evaluation of RESI, REFS, and AutoAnnotator.

Modal window (Chen 2011)

A modal window is a child window that requires the user to interact with it before they can return to operating the parent application, thus preventing any work on the application main window.

Musical store (Deeptimahanti and Sanyal 2008, 2009)

The musical store receives tape requests from customers. The musical store receives new tapes from the Main office. Musical store sends overdue notice to customers. Store assistant takes care of tape requests. Store assistant update the rental list. Store management submits the price changes. Store management submits new tapes. Store administration produces rental reports. Main office sends overdue notices for tapes. Customer request for a tape. Store assistant checks the availability of requested tape. Store assistant searches for the available tape. Store assistant searches for the rental price of available tape. Store assistant checks status of the tape to be returned by customer. Customer can borrow if there is no delay with return of other tapes. Store assistant records rental by updating the rental list. Store assistant asks the customer for his address.

Circe (Ambriola and Gervasi 2006)

The system is made of the Web interface, of Cico, of the view modules, and of the view selector. The Web interface receives from the user requirements and glossary. Requirements contain data on the team, on the author and on the revision. The Web interface transmits to Cico requirements and glossary. If the project is cooperative, the Web interface sends requirements and glossary to the repository, too. Cico computes abstract requirements using requirements, glossary, MAS-rules, predefined glossary and team data. If the project is cooperative, Cico requests team data to the repository. The view modules receive abstract requirements from Cico. The view modules can be dedicated to modeling, validation or metrication. From abstract requirements, view modules compute a view. The view module sends the view to the view selector. The user requests a view to the view selector.

Monitoring pressure (Berry et al. 2003)

The system monitors the pressure and sends the safety injection signal when the pressurizer’s pres-sure falls below a “low” threshold. The human operator can override system actions by turning on a “Block” button and resets the manual block by pushing on a “Reset” button. A manual block is permitted if and only if the pressure is below a “permit” threshold. The manual block must be automatically reset by the system. A manual block is effective if and only if it is executed before the safety injection signal is sent. The “Reset” button has higher priority than the “Block” button.

ATM (Rumbaugh et al. 1991)

Design the software to support a computerized banking network including both human cashiers and automatic teller machines ATMs to be shared by a consortium of banks. Each bank provides its own computer to maintain its own accounts and process transactions against them. Cashier stations are owned by individual banks and communicate directly with their own bank’s computer. Human cashiers enter account and transaction data. Automatic teller machines communicate with a central computer which clears transactions with the appropriate banks. An automatic teller machine accepts a cash card, interacts with the user, communicates with the central system to carry out the transaction, dispenses cash, and prints receipts. The system requires appropriate record keeping and security provisions. The system must handle concurrent accesses to the same account correctly. The banks will provide their own software for their own computers; you are to design the software for the ATMs and the network. The cost of the shared system will be apportioned to the banks according to the number of customers with cash cards.

Steam boiler (Abrial et al. 1996)

The general purpose of the steam boiler system, as shown in Fig. 1, is to ensure a safe operation of the steam boiler. The steam boiler operates safely if the contained amount of water never exceeds a certain tolerance, thus avoiding damage to the steam boiler and the turbine driven by the produced steam. Basically, the steam boiler system consists of the steam boiler itself, a measuring device for the water level, a pump to provide the steam boiler with water, a measuring device for the pump status, a measuring device for the amount of steam produced by the steam boiler, an operator desk, and a message transmission system for the signals produced. During operation, the water level is kept within the tolerance level as long as possible, using the measuring devices and the pump and producing status information for the operator desk. But even with some devices broken, the system can still successfully monitor the steam boiler. If no safe operation is possible any longer, control is handed over to the operator desk. Additionally, the operator can stop the system at any time via the operator desk.

ABC video rental (Kiyavitskaya et al. 2008)

Customers select at least one video for rental. The maximal number of tapes that a customer can have outstanding on rental is 20. The customer’s account number is entered to retrieve customer data and create an order. Each customer gets an id card from ABC for identification purposes. This id card has a bar code that can be read with the bar code reader. Bar code Ids for each tape are entered and video information from inventory is displayed. The video inventory file is updated. When all tape Ids are entered, the system computes the total bill. Money is collected and the amount is entered into the system. Change is computed and displayed. The rental transaction is created, printed and stored. The customer signs the rental form, takes the tapes and leaves. To return a tape, the video bar code ID is entered into the system. The rental transaction is displayed and the tape is marked with the date of return. If past-due amounts are owed they can be paid at this time; or the clerk can select an option which updates the rental with the return date and calculates past-due fees. Any outstanding video rentals are displayed with the amount due on each tape and the total amount due. Any past-due amount must be paid before new tapes can be rented.

Cinema

This text was used in a software engineering exam at our chair.

At first, the user selects the movie show for which he would like to book tickets. This he does by clicking on the relevant film or the desired date. Depending on the selection, a list with movie shows for the selected film or a list of movie shows of the selected day is displayed. Then he clicks on the movie show for which he would like to order tickets. If there are any of the 30 orderable tickets left, he is prompted to enter his name, his e-mail address, and the desired number of cards. He can also specify whether he wants to be reminded of the movie show by e-mail. After a click on order, the system attempts to allocate the desired cards. If this is possible, a confirmation page is displayed on which all the provided information is summarized again. If the tickets for this movie show can not be reserved, there will be an error message and the user is prompted to reduce the number of cards or select a different idea.

Timbered house

This text was used in a software engineering exam at our chair.

A timbered house consists of 5–10 logs, 200–400 mud-bricks and 1,000 to 2,000 nails. Each building material, whether log, brick, or nail, is a component in exactly one timbered house. Each timbered house has a certain number of rooms and floors. For the construction of a timbered house is at least one carpenter in charge, which has a name and an individual hourly wage. For the construction of a timbered house, each carpenter uses his own tools, consisting of exactly one hammer and exactly one saw. Any carpenter can work on up to one timbered house at the same time.

WHOIS protocol (Daigle 2004)

A WHOIS server listens on TCP port 43 for requests from WHOIS clients. The WHOIS client makes a text request to the WHOIS server then the WHOIS server replies with text content. All requests are terminated with ASCII CR and then ASCII LF. The response might contain more than one line of text so the presence of ASCII CR or ASCII LF characters does not indicate the end of the response. The WHOIS server closes the connection as soon as the output is finished. The closed connection is the indication to the WHOIS client that the response has been received.

Rights and permissions

Reprints and Permissions

About this article

Cite this article

Landhäußer, M., Körner, S.J. & Tichy, W.F. From requirements to UML models and back: how automatic processing of text can support requirements engineering. Software Qual J 22, 121–149 (2014). https://doi.org/10.1007/s11219-013-9210-6

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11219-013-9210-6

Keywords

  • Natural language specification
  • Ontology
  • Modeling
  • UML