References

Alan, D. R., Wixom, B. H., & Tegarden, D. (2012). Systems analysis and design with UML, Version 2.0: An object-oriented approach (4th ed.). Hoboken, NJ: Wiley.

Al-Barak, M., & Bahsoon, R. (2016). Database design debts through examining schema evolution. In Proceedings of the IEEE Eighth International Workshop on Managing Technical Debt (pp. 17–23). Piscataway, NJ: IEEE Computer Society Press.

Albrecht, A. J., & Gaffney, J. R. (1983). Software function, source lines of code, and development effort prediction: A software science validation. IEEE Transactions on Software Engineering, 9(6), 639–648.

Ambler, S. (2017). 11 strategies for dealing with technical debt. Retrieved from http://www.disciplinedagiledelivery.com/technical-debt/

Ambler, S. W. (2011). Agility at scale. Become as agile as you can be. Retrieved from https://www.ibm.com/developerworks/community/blogs/ambler?lang=en

Ampatzoglou, A., Ampatzoglou, A., Chatzigeorgiou, A., Avgeriou, P., Abrahamsson, P., Martini, A., …Systä, K. (2016). The perception of technical debt in the embedded systems domain: An industrial case study. In Proceedings of the 2016 IEEE 8th International Workshop on Managing Technical Debt (pp. 9–16). Piscataway, NJ: IEEE Computer Society.

Arcelli-Fontana, F., Ferme, V., Zanoni, M., & Roveda, R. (2015). Towards a prioritization of code debt: A code smell Intensity Index. In Proceedings of the IEEE Seventh International Workshop on Managing Technical Debt (pp. 16–24). Piscataway, NJ: IEEE Press.

Arulraj, J. (2018). SQL Check. https://github.com/jarulraj/sqlcheck

Avgeriou, P., Kruchten, P., Ozkaya, I., & Seaman, C. (Eds.). (2016). Managing technical debt in software engineering (Dagstuhl Seminar 16162). Dagstuhl Reports (Vol. 6, pp. 110–138). Dagstuhl, Germany: Schloss Dagstuhl–Leibniz-Zentrum fáür Informatik. http://dx.doi.org/10.4230/DagRep.6.4.110

Baldwin, C. Y., & Clark, K. B. (2000). Design rules: The power of modularity. Cambridge, MA: MIT Press.

Basili, V. R., Caldiera, G., & Rombach, D. (1994). The Goal Question Metric approach. In R. Van Solingen (Ed.), Encyclopedia of Software Engineering (pp. 528–532). Hoboken, NJ: Wiley.

Bass, L., Clements, P., & Kazman, R. (2012). Software architecture in practice (3rd d.). Reading, MA: Addison-Wesley.

Bass, L., Weber, I., & Zhu, L. (2016). DevOps: A software architect’s perspective. Boston: Addison-Wesley Professional.

Bavota, G., & Russo, B. (2016). A large-scale empirical study on self-admitted technical debt. In Proceedings of the 2016 IEEE/ACM 13th Working Conference on Mining Software Repositories (pp. 315–326). New York: ACM.

Becker, C., Chitchyan, R., Duboc, L., Easterbrook, S., Penzenstadler, B., Seyff, N., & Venters, C. (2015). Sustainability design and software: The Karlskrona Manifesto. In Proceedings of the 37th International Conference on Software Engineering, Vol. 2 (pp. 467–476). Piscataway, NJ: IEEE Press.

Bellomo, S., Kruchten, P., Nord, R. L., & Ozkaya, I. (2014). How to agilely architect an agile architecture. Cutter IT Journal, 27(2), 12–17.

Bellomo, S., Nord, R. L., Ozkaya, I., & Popeck, M. (2016). Got technical debt? Surfacing elusive technical debt in issue trackers. In Proceedings of the 2016 IEEE/ACM 13th Working Conference on Mining Software Repositories (pp. 327–338). New York: ACM.

Bergey, J., Cohen, S., Donohoe, P., & Jones, L. (2005). Software product lines: Experiences from the Seventh DoD Software Product Line Workshop (CMU/SEI-2005-TR-001). Pittsburgh: Software Engineering Institute.

Beyer, B., Jones, C., Petoff, J., & Murphy, N. R. (Eds.). (2016). Site reliability engineering. Sebastopol, CA: O’Reilly.

Boehm, B., Clark, B. K., Brown, A. W., & Abts, C. (2000). Software cost estimation with Cocomo II. Upper Saddle River, NJ: Prentice Hall.

Booch, G. (2000). The future of software (abstract). In Proceedings of the 22nd International Conference on Software Engineering (p. 3). New York: ACM.

Brooks, F. P. (1986). No silver bullet—Essence and accident in software engineering. In H.-J. Kugler (Ed.), Proceedings of the IFIP Tenth World Computing Conference (pp. 1069–1076). Amsterdam: Elsevier Science B.V.

Brooks, F. P. (1995). The mythical man-month: Essays on software engineering (anniversary ed.). Reading, MA: Addison-Wesley.

Brown, S. (2018). Software architecture for developers. Vancouver, BC: Leanpub.

Cervantes, H., & Kazman, R. (2016). Designing software architectures: A practical approach. Boston: Addison-Wesley Professional.

Clements, P., Bachmann, F., Bass, L., Garlan, D., Ivers, J., Little, R., …Stafford, J. (2011). Documenting software architectures: Views and beyond (2nd ed.). Reading, MA: Addison-Wesley.

Clements, P., Kazman, R., & Klein, M. (2001). Evaluating software architectures: Methods and case studies. Reading, MA: Addison-Wesley.

Cohn, M. (2016). What are story points? Retrieved from https://www.mountaingoatsoftware.com/blog/what-are-story-points

Consortium for IT Software Quality (CISQ). http://it-cisq.org/

Cunningham, W. (1992). The WyCash Portfolio Management System. Presented at OOPSLA 1992, Vancouver. Available at http://dl.acm.org/citation.cfm?id=157715

Davis, A. M. (1995). 201 principles of software development. New York: McGraw-Hill.

Dijkstra, E. W. (1972). The humble programmer. Communications of the ACM, 15(10), 859–866.

Fairbanks, G. (2010). Just enough software architecture: A risk-driven approach. Boulder, CO: Marshall & Brainerd.

Fayolle, J. P., Coq, T., & Letouzey, J.-L. (2018). The Agile Alliance debt analysis model (A2DAM). Agile Alliance. Retrieved from https://www.agilealliance.org/the-agile-alliance-debt-analysis-model/

Feathers, M. (2004). Working effectively with legacy code. Upper Saddle River, NJ: Pearson Education.

Ford, N., Parsons, R., & Kua, P. (2017). Building evolutionary architectures:Support constant change. Sebastopol, CA: O’Reilly Media.

Forsgren, N., Humble, J., & Kim, G. (2017). Forecasting the value of DevOps transformations: Measuring ROI of DevOps. Beaverton, OR: DevOps Research and Assessment (DORA).

Fowler, M. (2003). Technical debt. Retrieved from http://martinfowler.com/bliki/TechnicalDebt.html

Fowler, M. (2009). Technical debt quadrants. Retrieved from https://martinfowler.com/bliki/TechnicalDebtQuadrant.html

Fowler, M. (2018). Refactoring: Improving the design of existing code. Reading, MA: Addison-Wesley.

Freeman, S., & Matt, C. (2014). Is unhedged call options a better metaphor for bad code? InfoQueue. Retrieved from https://www.infoq.com/news/2014/12/call-options-bad-code

Gibbs, W. W. (1994). Software’s chronic crisis. Scientific American, 271(3), 72–81.

Glass, R. L. (2003). Facts and fallacies of software engineering. Boston: Addison-Wesley.

Google. (2018). Google Java standard guide. Retrieved from https://google.github.io/styleguide/javaguide.html

Gorton, I. (2006). Essential software architecture (2nd ed.). Berlin: Springer.

Grenning, J. (2002). Planning poker. Retrieved from https://wingman-sw.com/papers/PlanningPoker-v1.1.pdf

Guo, Y., Spínola, R. O., & Seaman, C. B. (2016). Exploring the costs of technical debt management: A case study. Empirical Software Engineering, 21(1), 159–182.

Hastie, S. (2010). What color is your backlog? InfoQ Magazine. Retrieved from http://www.infoq.com/news/2010/05/what-color-backlog

Highsmith, J. A. (2002). Agile software development ecosystems. Boston: Addison-Wesley.

Highsmith, J. A. (2010). The financial implications of technical debt. Retrieved from http://jimhighsmith.com/the-financial-implications-of-technical-debt/

International Organization for Standardization/International Electrotechnical Commission (IEC). (2009). ISO/IEC 20926:2009 Software and systems engineering—Software measurement—IFPUG functional size measurement method. Geneva, Switzerland: ISO.

International Organization for Standardization/International Electrotechnical Commission. (2011). ISO/IEC 25010:2011 Systems and software engineering—Systems and software Quality Requirements and Evaluation (SQuaRE)—System and software quality models. Geneva, Switzerland: ISO/IEC. https://www.iso.org/standard/35733.html

Kazman, R., Cai, Y., Mo, R., Feng, Q., Xiao, L., Haziyev, S., …Shapochka, A. (2015). A case study in locating the architectural roots of technical debt. In Proceedings of the International Conference on Software Engineering (ICSE ’15), Vol. 2. (pp. 179–188). Piscataway, NJ: IEEE Press.

Kerievski, J. (2004). Refactoring to patterns. Boston: Addison-Wesley.

Kim, G., Behr, K., & Spafford, G. (2013). The Phoenix Project: A novel about IT, DevOps, and helping your business win. Portland, OR: IT Revolution Press.

Kim, G., & Debois, P. (2016). The DevOps handbook: How to create world-class agility, reliability, and security in technology organizations. Portland, OR: IT Revolution Press.

Klotins, E., Unterkalmsteiner, M., Chatzipetrou, P., Gorschek, T., Prikladnicki, R., Tripathi, N., & Pompermaier, L. B. (2018). Exploration of technical debt in start-ups. In Proceedings of the 40th International Conference on Software Engineering: Software Engineering in Practice (pp. 75–84). New York: ACM.

Knodel, J., & Naab, M. (2016). Pragmatic evaluation of software architecture. Berlin: Springer.

Kruchten, P. (2011). The (missing) value of software architecture. Retrieved from http://philippe.kruchten.com/2013/12/11/the-missing-value-of-software-architecture/

Kruchten, P. (2013). Contextualizing agile software development. Journal of Software Evolution and Process, 25(4), 351–361.

Kruchten, P., Nord, R., & Ozkaya, I. (2012). Technical debt: From metaphor to theory and practice. IEEE Software, 29(6), 18–21.

Kruchten, P., Nord, R. L., Ozkaya, I., & Falessi, D. (2013). Technical debt: Towards a crisper definition; report on the 4th International Workshop on Managing Technical Debt. SIGSOFT Software Engineering Notes, 38(5), 51–54.

Leffingwell, D. (2007). Scaling software agility: Best practices for large enterprises. Boston: Addison-Wesley.

Lehman, M. M. (1980). On understanding laws, evolution, and conservation in the large program lifecycle. Journal of Systems and Software, 1(3), 213–221.

Lehman, M. M. (1996). Laws of software evolution revisited. In C. Montangero (Ed.), Software Process Technology: Fifth European Workshop (pp. 108–124). Berlin: Springer.

Letouzey, J.-L. (2016). The SQALE method for managing technical debt: Definition document (Version 1.1). Retrieved from http://www.sqale.org/wp-content/uploads/2016/08/SQALE-Method-EN-V1-1.pdf

Letouzey, J.-L., & Ilkiewicz, M. (2012). Managing technical debt with the SQALE method. IEEE Software, 29(6), 44–51.

Li, Z., Liang, P., & Avgeriou, P. (2015). Architectural technical debt identification based on architecture decisions and change scenarios. In Proceedings of the 12th Working IEEE/IFIP Conference on Software Architecture (WICSA ’15) (pp. 65–74). Piscataway, NJ: IEEE.

Lim, E., Taksande, N., & Seaman, C. B. (2012). A balancing act: What software practitioners have to say about technical debt. IEEE Software, 29(6), 22–27.

Mancuso, S. (2014). The software craftsman: Professionalism, pragmatism, pride. Upper Saddle River, NJ: Prentice Hall.

Martin, R. (2008). Clean code: A handbook of agile software craftsmanship. Upper Saddle River, NJ: Prentice Hall.

McConnell, S. (2007). Technical debt. Retrieved from https://www.construx.com/resources/whitepaper-managing-technical-debt/

Morris, K. (2016). Infrastructure as code: Managing servers in the cloud. Sebastopol, CA: O’Reilly.

Object Management Group. (2017). Automated technical debt measure, Version 1, Beta 2 (OMG Document Number: admtf/2017-03-01). Retrieved from http://www.omg.org/spec/ATDM/

Parnas, D. L. (1994). Software aging. In Proceedings of the 16th InternationalConference on Software Engineering (pp. 279–287). Los Alamitos, CA: IEEE Computer Society.

Poort, E. (2014). The business case for technical debt reduction. Retrieved from https://eltjopoort.nl/blog/2014/01/27/the-business-case-for-technical-debt-reduction/

Poort, E. (2016). Just enough anticipation: Architect your time dimension. IEEE Software, 33(6), 11–15.

Potdar, A., & Shihab, E. (2014). An exploratory study on self-admitted technical debt. In Proceedings of the 2014 IEEE International Conference on Software Maintenance and Evolution (pp. 91–100). Piscataway, NJ: IEEE Press.

Ramasubbu, N., & Kemmerer, C. (in press). Integrating technical debt management and software quality management processes: A normative framework and field tests. IEEE Transactions on Software Engineering.

Redgate Software Ltd. (2018). SQL Code Guard, 3.0. https://www.red-gate.com/products/sql-development/sql-code-guard/

Reifer, D. (2001). Making the software business case: Improvement by the numbers. Upper Saddle River, NJ: Addison-Wesley.

Ries, E. (2011). The lean startup. New York: Crown Business.

Rozanski, N., & Woods, E. (2012). Software systems architecture: Working with stakeholders using viewpoints and perspectives (2nd ed.). Upper Saddle River, NJ: Addison-Wesley.

Sadowski, C., Aftandilian, E., Eagle, A., Miller-Cushon, L., & Jaspan, C. (2018). Lessons from building static analysis tools at Google. Communications of the ACM, 61(4), 58–66.

Scaled Agile, Inc. (n.d.). Scaled Agile Framework (SAFe). Retrieved from https://www.scaledagileframework.com/

Schmid, K. (2013a). A formal approach to technical debt decision making. In Proceedings of the Ninth International ACM Sigsoft Conference on Quality of Software Architectures (pp. 153–162). New York: ACM.

Schmid, K. (2013b). On the limits of the technical debt metaphor: Some guidance on going beyond. In Proceedings of the Fourth International Workshop on Managing Technical Debt (pp. 63–66). Washington, DC: IEEE Computer Society Press.

Sculley, D., Holt, G., Golovin, D., Davydov, E., Phillips, T., Ebner, D., …Dennison, D. (2015). Hidden technical debt in machine learning systems. In C. Cortes, D. D. Lee, M. Sugiyama, & R. Garnett (Eds.), Proceedings of the 28th International Conference on Neural Information Processing Systems, Volume 2 (pp. 2503–2511). Cambridge, MA: MIT Press.

Séguin, N., Tremblay, G., & Bagane, H. (2012). Agile principles as software engineering principles: An analysis. In C. Wohlin (Eds.), LNCS 111, pp. 1–15. Berlin: Springer.

Shafer, A. C. (2010). Infrastructure debt: Revisiting the foundation. Cutter ITJournal, 23(10), 36–41.

Sharma, S. (2017). The DevOps adoption playbook: A guide to adopting DevOps in a multi-speed IT enterprise. Indianapolis: Wiley.

Software Engineering Institute. (2018). SEI CERT secure coding standards. ­Pittsburgh: SEI. https://www.securecoding.cert.org

Tom, E., Aurum, A., & Vidgen, R. (2012a). A consolidated understanding of technical debt. In Proceedings of the European Conference on Information Systems (Paper 16).

Tom, E., Aurum, A., & Vidgen, R. (2012b). An exploration of technical debt. Journal of Systems and Software, 86(6), 1498–1516.

Tornhill, A. (2018). Software design x-rays: Fix technical debt with behavioral code analysis. Raleigh, NC: The Pragmatic Bookshelf.

Visser, J., Rigal, S., van der Leek, R., van Eck, P., & Wijnholds, G. (2016). Building maintainable software: Ten guidelines for future-proof code. Sebastopol, CA: O’Reilly Media.

Weber, J., Cleve, A., Meurice, L., & Ruiz, F. J. B. (2014). Managing technical debt in database schemas of critical software. In Proceedings of the Sixth International Workshop on Managing Technical Debt (pp. 43–46). Piscataway, NJ: IEEE Computer Society Press.

Wikipedia. (2018). Software architecture. https://en.wikipedia.org/wiki/Software_architecture

Zazworka, N., Vetro, A., Izurieta, C., Wong, S., Cai, Y., Seaman, C. B., & Shull, F. (2014). Comparing four approaches for technical debt identification. Software Quality Journal, 22(3), 403–426.

Zimmermann, T., Premraj, R., Bettenburg, N., Just, S., Schröter, A., & Weiss, C. (2010). What makes a good bug report? IEEE Transactions on Software Engineering, 36(5), 618–643.