Logo PTI
Polish Information Processing Society
Logo FedCSIS

Annals of Computer Science and Information Systems, Volume 11

Proceedings of the 2017 Federated Conference on Computer Science and Information Systems

Use Case Driven Modularization as a Basis for Test Driven Modularization


DOI: http://dx.doi.org/10.15439/2017F343

Citation: Proceedings of the 2017 Federated Conference on Computer Science and Information Systems, M. Ganzha, L. Maciaszek, M. Paprzycki (eds). ACSIS, Vol. 11, pages 693696 ()

Full text

Abstract. While in waterfall-like processes changes are expected to happen mostly after the main development has finished, agile approaches have incorporated response to changes into the main development itself, which raises the importance of the ability to respond to changes effectively to a sine qua non. Changes are specified from the perspective of how users actually use systems, i.e., usage scenarios, which does not correspond to a common object-oriented code modularization. In their complete form, usage scenarios can be directly observed in user acceptance tests. Unit tests reveal parts of usage scenarios, too. Logically, tests follow the modularization of the code they are related to. Thus, in common object-oriented code, user acceptance tests, which play a very important role in any kind of software development process and which follow the procedural modularization, would be scattered and, consequently, hard to maintain. In this paper, we propose a new approach capable of achieving test driven modularization, i.e., organizing code according to tests. Besides pure test driven modularization, which can be based on user acceptance tests, unit tests, or both, the approach also enables combining use case and test driven modularization.


  1. M. Bystrický and V. Vranić. Literal inter-language use case driven modularization. In Proceedings of LaMOD’16: Language Modularity À La Mode, workshop, Modularity 2016, Málaga, Spain, 2016. ACM. http://dx.doi.org/10.1145/2892664.2893465.
  2. M. Bystrický and V. Vranić. Preserving use case flows in source code: Approach, context, and challenges. Computer Science and Information Systems Journal (ComSIS), 14(2):423–445, 2017. http://dx.doi.org/10.2298/CSIS151101005B.
  3. J. Bálik and V. Vranić. Symmetric aspect-orientation: Some practical consequences. In Proceedings of NEMARA 2012: International Workshop on Next Generation Modularity Approaches for Requirements and Architecture, at AOSD 2012, Potsdam, Germany, 2012. ACM. http://dx.doi.org/10.1145/2162004.2162007.
  4. J. Coplien and G. Bjørnvig. Lean Architecture for Agile Software Development. Wiley, 2010.
  5. K. Czarnecki and U. Eisenecker. Generative Programming: Methods, Tools, and Applications. Addison-Wesley, 2000.
  6. J. Franců and P. Hnětynka. Automated code generation from system requirements in natural language. e-Informatica Software Engineering Journal, 3(1):72–88, 2009.
  7. S. Garg. Cucumber Cookbook. Packt Publishing, 2015.
  8. D. Harel, A. Marron, and G. Weiss. Behavioral programming. Communications of the ACM, 55(7):90–100, July 2012. http://dx.doi.org/10.1145/2209249.2209270.
  9. W. H. Harrison, H. L. Ossher, and P. L. Tarr. Asymmetrically vs. symmetrically organized paradigms for software composition. Technical Report RC22685, IBM Research, 2002.
  10. S. Herrmann. A precise model for contextual roles: The programming language ObjectTeams/Java. Applied Ontology, 2(2):181–207, 2007.
  11. I. Jacobson. Use cases and aspects – working seamlessly together. Journal of Object Technology, 2(4), 2003. http://dx.doi.org/10.5381/jot.2003.2.4.c1.
  12. I. Jacobson and P.-W. Ng. Aspect-Oriented Software Development with Use Cases. Addison-Wesley, 2004.
  13. A. Johnson and B. Johnson. Literate programming using (noweb). Linux Journal, 1997(42es), 1997.
  14. D. E. Knuth. Literate programming. The Computer Journal, 27(2):97–111, 1984.
  15. E. W. Myers. An o(nd) difference algorithm and its variations. Algorithmica, 1:251–266, 1986.
  16. M. Nosáĺ. Sieve source code editor. https://github.com/MilanNosal/sieve-source-code-editor, 2015.
  17. H. Ossher, W. Harrison, F. Budinsky, and I. Simmonds. Subject-oriented programming: Supporting decentralized development of objects. In Proceedings of 7th IBM Conference on Object-Oriented Technology, 1994.
  18. M. Rahman and J. Gao. A reusable automated acceptance testing architecture for microservices in behavior-driven development. In 2015 IEEE Symposium on Service-Oriented System Engineering, SOSE 2015, 2015. http://dx.doi.org/10.1109/SOSE.2015.55.
  19. T. Reenskaug and J. O. Coplien. The DCI architecture: A new vision of object-oriented programming. Artima Developer, 2009.
  20. K. Rástočný and M. Bieliková. Empirical metadata maintenance in source code development process. In 4th Eastern European Regional Conference on the Engineering of Computer Based Systems, 2015. http://dx.doi.org/10.1109/ECBS-EERC.2015.13.
  21. M. Sulír and M. Nosál’. Sharing developers’ mental models through source code annotations. In Proceedings of 2015 Federated Conference on Computer Science and Information Systems, FedCSIS 2015, Łódź, Poland, 2015. IEEE. http://dx.doi.org/10.15439/2015F301.
  22. P. Zielczynski. Traceability from use cases to test cases, 2006. IBM developerWorks, https://www.ibm.com/developerworks/rational/library/04/r-3217/.
  23. M. Śmiałek, N. Jarzębowski, and W. Nowakowski. Translation of use case scenarios to Java code. Computer Science, 13(4):35–52, 2012. http://dx.doi.org/10.7494/csci.2012.13.4.35.