Bibliography

  1. Aho, A., Lam, M., Sethi, R., and Ullman, J. (2006). Compilers: Principles, Techniques, and Tools. Addison-Wesley.
  2. Alexander, C. (1977). A Pattern Language: Towns, Buildings, Construction. Oxford University Press.
  3. Allison, C. (2006). Where did all my decimals go? Journal of Computing Sciences in Colleges 21 (3): 47–59.
  4. Augustin . (2017). C++ unit testing in Visual Studio. C++ Team Blog. https://blogs.msdn.microsoft.com/vcblog/2017/04/19/cpp-testing-in-visual-studio.
  5. Filipek, B. R. (2018). C++17 in Detail. Independently published https://www.bfilipek.com/2018/08/cpp17indetail.html.
  6. Boccara, J. (2016). Strong types for strong interfaces. Fluent {C++}. https://www.fluentcpp.com/2016/12/08/strong-types-for-strong-interfaces.
  7. Boccara, J. (2018). Getting the benefits of strong typing in C++ at a fraction of the cost. Fluent {C++}. https://www.fluentcpp.com/2018/04/06/strong-types-by-struct.
  8. Boost.org (2020). Boost C++ libraries. https://www.boost.org.
  9. Bryant, R. and O'Hallaron, D. (2015). Computer Systems. A Programmer's Perspective. Prentice Hall.
  10. Catch Org (2019). Catch2. https://github.com/catchorg/Catch2.
  11. Cohn, J. (2019). Scrum Fundamentals: A Beginner's Guide to Mastery of the Scrum Project Management Methodology. Independently published.
  12. Coplien, J. (1995). Curiously recurring template patterns. C++ Report 7 (2): 24–27.
  13. Cormen, T.H., Leiserson, C.E., Rivest, R.L.i., and Stein, C. (2009). Introduction to Algorithms. MIT Press.
  14. Cover, T.M.i. and Thomas, J.A. (2006). Elements of Information Theory. Wiley-Interscience.
  15. Cplusplus.com (2020). http://cplusplus.com.
  16. Cppreference.com (2018). Filesystem library. https://en.cppreference.com/w/cpp/experimental/fs.
  17. Cppreference.com (2019a). Date and time utilities. https://en.cppreference.com/w/cpp/chrono.
  18. Cppreference.com (2019b). Template argument deduction. https://en.cppreference.com/w/cpp/language/template_argument_deduction
  19. Cppreference.com (2020a). Template parameters arguments. https://en.cppreference.com/w/cpp/language/template_parameters.
  20. Cppreference.com (2020b). http://cppreference.com.
  21. Cppreference.com (2020c). Operator overloading. https://en.cppreference.com/w/cpp/language/operators.
  22. Čukić, I. (2019). Functional Programming in C++. Manning Publications Co.
  23. Cyganek, B. (2013). Object Detection and Recognition in Digital Images: Theory and Practice. New-York: Wiley.
  24. Cyganek, B. (2020). CppBook web page. http://home.agh.edu.pl/~cyganek/BookCpp.htm
  25. Dalheimer, M.K. and Welsh, M. (2006). Running Linux: A Distribution-Neutral Guide for Servers and Desktops, 5e. O'Reilly Media.
  26. Dick, G., van Reeuwijk, K., Bal, H.E. et al. (2012). Modern Compiler Design. Springer.
  27. Dick, J., Hull, E., and Jackson, K. (2017). Requirements Engineering. Springer.
  28. Douglass, B. (2006). Real Time UML. Boston: Addison Wesley.
  29. Fan, X. (2015). Real-Time Embedded Systems. Design Principles and Engineering Practices. Kidlington: Newnes-Elsevier.
  30. FLTK Team (2019). Fast Light Toolkit (FLTK). www.fltk.org.
  31. Fowler, M. (1999). Refactoring: Improve the Design of Existing Code. Boston: Addison Wesley.
  32. Gamma, E., Helm, R., Johnson, R., and Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. New-York: Addison-Wesley Professional.
  33. Goldberg, D. (1991). What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys 23 (1): 5–48.
  34. Google (2019). Googletest Google testing and mocking framework. https://github.com/google/googletest.
  35. Grune, D., van Reeuwijk, K., Bal, H.E. et al. (2012). Modern Compiler Design. Heidelberg: Springer.
  36. Hinde, D. (2018). PRINCE2 Study Guide: 2017 Update. Sybex.
  37. Josuttis, N.M. (2012). The C++ Standard Library: A Tutorial and Reference. New-York: Addison-Wesley Professional.
  38. Kahan, W. (1965). Further remarks on reducing truncation errors. Communications of the ACM 8 (1): 40.
  39. Kernighan, B. and Ritchie, D. (1988). C Programming Language, 2e. Chicago: Prentice Hall.
  40. Kerrisk, M. (2010). The Linux Programming Interface: A Linux and UNIX System Programming Handbook. The Starch Press.
  41. Knuth, D. (1998). The Art of Computer Programming. Seminumerical Algorithms, 3e, vol. 2. New York: Addison-Wesley.
  42. Korn, G. and Korn, T. (2000). Mathematical Handbook for Scientists and Engineers: Definitions, Theorems, and Formulas for Reference and Review, 2e. Dover: Dover Publications.
  43. Liskov, B. (1988). Data abstraction and hierarchy. OOPSLA '87. https://doi.org/10.1145/62138.62141.
  44. Martin, R.C. (2009). Getting a SOLID start. Clean Coder. https://sites.google.com/site/unclebobconsultingllc/getting-a-solid-start
  45. Matloff, N. and Salzman, J. (2008). The Art of Debugging with GDB, DDD and Eclipse. No Starch Press.
  46. McConnell, S. (2004). Code Complete (Developer Best Practices), 2e. New-York: Microsoft Press.
  47. Meyer, B. (1997). Object-Oriented Software Construction, 2e. New-York: Prentice Hall.
  48. Meyers, S. (2014). Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14. Chicago: O'Reilly Media.
  49. Niebler, E. (2019). Range-v3. https://ericniebler.github.io/range-v3.
  50. OpenMP (2020). www.openmp.org.
  51. O'Regan, G. (2019). Concise Guide to Software Testing. Springer.
  52. Pas, R.v., Stotzer, E., and Terboven, C. (2017). Using OpenMP – The Next Step. The MIT Press.
  53. Patterson, D. and Hennessy, J. (2018). Computer Organization and Design. The Hardware/Software Interface. Morgan Kaufman.
  54. Press, W., Teukolsky, S., Vetterling, W., and Flannery, B. (2007). Numerical Recipes: The Art of Scientific Computing, 3e. Cambridge: Cambridge University Press.
  55. Rozental, G. and Enficiaud, R. (2019). Boost.Test. https://www.boost.org/doc/libs/1_72_0/libs/test/doc/html/index.html.
  56. Schmidt, B.i. and Gonzalez-Dominguez, J. (2017). Parallel Programming: Concepts and Practice. Morgan Kaufman.
  57. Sommerville, I. (2016). Software Engineering. Addison-Wesley.
  58. Soulami, T. (2012). Inside Windows Debugging. Practical Debugging and Tracing Strategies. Microsoft Press.
  59. Stack Overflow (2020). http://stackoverflow.com.
  60. Standard C++ Foundation (2019). Get started! https://isocpp.org/get-started
  61. Stroustrup, B. (2007). Evolving a language in and for the real world: C++ 1991-2006. http://www.stroustrup.com/hopl-almost-final.pdf.
  62. Stroustrup, B. (2012). A tour of C++. Standard C++ Foundation. https://isocpp.org/tour.
  63. Stroustrup, B. (2013). The C++ Programming Language, 4e. New-York: Addison-Wesley Professional.
  64. Stroustrup, B. (2014). Programming: Principles and Practice Using C++, 2e. New-York: Addison-Wesley Professional.
  65. Stroustrup, B. and Sutter, H. (2019). C++ core guidelines. https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.
  66. Taligent, I. (1994). Taligent's Guide to Designing Programs: Well-Mannered Object-Oriented Design in C++. New-York: Taligent Press.
  67. Thomas, D. and Hunt, A. (2019). The Pragmatic Programmer: Your Journey to Mastery, 20th Anniversary Edition, 2e. Addison-Wesley Professional.
  68. Turner, J. (2016). C++ Weekly - Ep 7: Stop using std::endl. https://articles.emptycrate.com/2016/04/18/stop_using_std_endl.html.
  69. Unicode Consortium (2020). Unicode. http://unicode.org.
  70. Vandevoorde, D., Josuttis, N., and Gregor, D. (2017). C++ Templates: The Complete Guide, 2e. New-York: Addison-Wesley Professional.
  71. Wiki:Comparision_Executable (2019). Comparison of executable file formats. https://en.wikipedia.org/wiki/Comparison_of_executable_file_formats.
  72. Wiki:Floating-point (2020). Floating-point arithmetic. https://en.wikipedia.org/wiki/Floating-point_arithmetic.
  73. Wiki:Huffman_coding (2020). Huffman coding. https://en.wikipedia.org/wiki/Huffman_coding.
  74. Wiki:IEEE-754 (2020). IEEE 754. https://en.wikipedia.org/wiki/IEEE_754.
  75. Wiki:Portable_Executable (2020). Portable executable. https://en.wikipedia.org/wiki/Portable_Executable.
  76. Wiki:Proxy_pattern (2020). Proxy pattern. https://en.wikipedia.org/wiki/Proxy_pattern.
  77. Wiki:Roman_numerals (2020). Roman numerals. https://en.wikipedia.org/wiki/Roman_numerals.
  78. Wirth, N. (1976). Algorithms + Data Structures = Programs. Prentice-Hall.
  79. Yehia, W. (2012). C++0x, scoped enums. IBM Developer. https://www.ibm.com/developerworks/rational/library/scoped-enums/index.html
  80. Yliluoma, J. (2016). Guide into OpenMP: Easy multithreading programming for C++. https://bisqwit.iki.fi/story/howto/openmp.