Skip to content

References

All bibliographic references for this book are consolidated here and follow APA 7th edition style.

Bibliography

  • Amdahl, G. M. (1967). Validity of the single processor approach to achieving large scale computing capabilities. AFIPS Conference Proceedings, 30, 483-485.
  • Avizienis, A., Laprie, J.-C., Randell, B., & Landwehr, C. (2004). Basic concepts and taxonomy of dependable and secure computing. IEEE Transactions on Dependable and Secure Computing, 1(1), 11-33.
  • Bacchelli, A., & Bird, C. (2013). Expectations, outcomes, and challenges of modern code review. In Proceedings of ICSE 2013. IEEE.
  • Baldwin, C. Y., & Clark, K. B. (2000). Design rules: The power of modularity (Vol. 1). MIT Press.
  • Beck, K. (2002). Test-driven development: By example. Addison-Wesley.
  • Beyer, B., Jones, C., Petoff, J., & Murphy, N. R. (Eds.). (2016). Site reliability engineering: How Google runs production systems. O'Reilly Media.
  • Brandolini, A. (2021). Introducing EventStorming: An act of deliberate collective learning. Leanpub.
  • Brewer, E. A. (2000). Towards robust distributed systems. Proceedings of the Annual ACM Symposium on Principles of Distributed Computing. https://people.eecs.berkeley.edu/~brewer/cs262b-2004/PODC-keynote.pdf
  • Brooks, F. P. (1975). The mythical man-month: Essays on software engineering. Addison-Wesley.
  • Cockburn, A. (2005). Hexagonal architecture. Alistair Cockburn. https://alistair.cockburn.us/hexagonal-architecture
  • Codd, E. F. (1970). A relational model of data for large shared data banks. Communications of the ACM, 13(6), 377-387.
  • Cohen, J., Teleki, S., & Brown, E. (2006). Best Kept Secrets of Peer Code Review. SmartBear. https://static1.smartbear.co/smartbear/media/pdfs/best-kept-secrets-of-peer-code-review_redirected.pdf
  • Conway, M. E. (1968). How do committees invent? Datamation, 14(4), 28-31.
  • Cybersecurity and Infrastructure Security Agency. (2023). Zero trust maturity model (Version 2.0). https://www.cisa.gov/resources-tools/resources/zero-trust-maturity-model
  • DeCandia, G., Hastorun, D., Jampani, M., Kakulapati, G., Lakshman, A., Pilchin, A., Sivasubramanian, S., Vosshall, P., & Vogels, W. (2007). Dynamo: Amazon's highly available key-value store. Proceedings of SOSP 2007, 205-220.
  • Dean, J., & Barroso, L. A. (2013). The tail at scale. Communications of the ACM, 56(2), 74-80.
  • Dijkstra, E. W. (1972). The humble programmer. Communications of the ACM, 15(10), 859-866.
  • Dijkstra, E. W. (1976). A discipline of programming. Prentice Hall.
  • Engineering Fundamentals Playbook. (n.d.). Profiling. https://microsoft.github.io/code-with-engineering-playbook/observability/profiling/
  • Engineering Fundamentals Playbook. (n.d.). Unit Testing. https://microsoft.github.io/code-with-engineering-playbook/automated-testing/unit-testing/
  • Erl, T., Carlyle, B., Pautasso, C., & Balasubramanian, R. (2012). SOA with REST: Principles, patterns, and constraints for building enterprise solutions with REST. Prentice Hall.
  • European Space Agency. (1996). Ariane 5 flight 501 failure: Report by the inquiry board. ESA.
  • Evans, E. (2003). Domain-driven design: Tackling complexity in the heart of software. Addison-Wesley.
  • Facebook Engineering. (2015). GraphQL: A data query language. https://engineering.fb.com/2015/09/14/core-infra/graphql-a-data-query-language/
  • Fagan, M. E. (1976). Design and code inspections to reduce errors in program development. IBM Systems Journal, 15(3), 182-211.
  • Fielding, R. T. (2000). Architectural styles and the design of network-based software architectures (Doctoral dissertation, University of California, Irvine). https://ics.uci.edu/~fielding/pubs/dissertation/top.htm
  • Foote, B., & Yoder, J. (1999). Big ball of mud. Proceedings of the 4th Conference on Pattern Languages of Programs.
  • Ford, N., Parsons, R., & Kua, P. (2022). Building evolutionary architectures (2nd ed.). O'Reilly Media.
  • Forsgren, N., Humble, J., & Kim, G. (2018). Accelerate. IT Revolution.
  • Fowler, M. (1999). Refactoring: Improving the design of existing code. Addison-Wesley.
  • Fowler, M. (2002). Patterns of enterprise application architecture. Addison-Wesley.
  • Fowler, M. (2004). Inversion of Control Containers and the Dependency Injection pattern. https://martinfowler.com/articles/injection.html
  • Fowler, M. (2012). Continuous Integration. https://martinfowler.com/articles/continuousIntegration.html
  • Fowler, M. (2015). Monolith first. https://martinfowler.com/bliki/MonolithFirst.html
  • Fowler, M. (2018). Test Pyramid. https://martinfowler.com/articles/practical-test-pyramid.html
  • Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design patterns: Elements of reusable object-oriented software. Addison-Wesley.
  • Garcia-Molina, H., & Salem, K. (1987). Sagas. Proceedings of the 1987 ACM SIGMOD International Conference on Management of Data, 249-259.
  • Gerhards, R. (2009). The Syslog Protocol (RFC 5424). IETF. https://www.rfc-editor.org/rfc/rfc5424
  • Google Open Source. (2015). gRPC: A high performance, open source universal RPC framework. https://grpc.io/
  • Graham, S. L., Kessler, P. B., & McKusick, M. K. (1982). gprof: A call graph execution profiler. Proceedings of the SIGPLAN Symposium on Compiler Construction.
  • GraphQL Foundation. (2021). GraphQL specification. https://spec.graphql.org/
  • GraphQL over HTTP Working Group. (n.d.). GraphQL over HTTP specification. https://graphql.github.io/graphql-over-http/draft/
  • Gray, J., & Reuter, A. (1992). Transaction processing: Concepts and techniques. Morgan Kaufmann.
  • Gregg, B. (2016). The flame graph. Communications of the ACM. https://queue.acm.org/detail.cfm?id=2927301
  • Gregg, B. (2020). Systems performance: Enterprise and the cloud (2nd ed.). Pearson.
  • Hartig, O., & Pérez, J. (2018). Semantics and complexity of GraphQL. Proceedings of the 2018 World Wide Web Conference, 1155-1164.
  • Hohpe, G., & Woolf, B. (2003). Enterprise integration patterns. Addison-Wesley.
  • Hohpe, G., & Woolf, B. (2004). Enterprise integration patterns. Addison-Wesley.
  • Humble, J., & Farley, D. (2010). Continuous delivery. Addison-Wesley.
  • IETF. (2022). RFC 9113: HTTP/2. https://www.rfc-editor.org/rfc/rfc9113
  • Jain, R. (1991). The art of computer systems performance analysis. Wiley.
  • Jericho Forum. (2007). Jericho forum commandments (Version 1.2). Open Group.
  • Kay, A. C. (1993). The early history of Smalltalk. ACM SIGPLAN Notices, 28(3), 69-95.
  • Kernighan, B. W., & Pike, R. (1999). The practice of programming. Addison-Wesley.
  • Kindervag, J. (2010). Build security into your network's DNA: The zero trust network architecture. Forrester Research.
  • Kleppmann, M. (2017). Designing data-intensive applications. O'Reilly Media.
  • Knuth, D. E. (1974). Structured programming with go to statements. ACM Computing Surveys, 6(4), 261-301.
  • Lamport, L. (1978). Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, 21(7), 558-565.
  • Lewis, J., & Fowler, M. (2014). Microservices. https://martinfowler.com/articles/microservices.html
  • Lieberherr, K. J., Holland, I. M., & Riel, A. J. (1988). Object-oriented programming: An objective sense of style. ACM SIGPLAN Notices, 23(11), 323-334.
  • Linux kernel documentation. (n.d.). perf: Linux profiling with performance counters. https://perf.wiki.kernel.org/index.php/Tutorial
  • Liskov, B. H., & Zilles, S. N. (1974). Programming with abstract data types. ACM SIGPLAN Notices, 9(4), 50-59.
  • Liskov, B., & Wing, J. M. (1994). A behavioral notion of subtyping. ACM Transactions on Programming Languages and Systems, 16(6), 1811-1841.
  • Liskov, B., & Zilles, S. (1974). Programming with abstract data types. SIGPLAN Notices, 9(4), 50-59.
  • Martin, R. C. (2003). Agile software development: Principles, patterns, and practices. Prentice Hall.
  • Martin, R. C. (2008). Clean code: A handbook of agile software craftsmanship. Prentice Hall.
  • Martin, R. C. (2017). Clean architecture: A craftsman's guide to software structure and design. Prentice Hall.
  • McIlroy, M. D. (1968). Mass produced software components. In P. Naur & B. Randell (Eds.), Software engineering: Report on a conference sponsored by the NATO Science Committee (pp. 138-150). Scientific Affairs Division, NATO.
  • Meszaros, G. (2007). xUnit test patterns: Refactoring test code. Addison-Wesley.
  • Meyer, B. (1988). Object-oriented software construction. Prentice Hall.
  • Meyer, B. (1997). Object-oriented software construction (2nd ed.). Prentice Hall.
  • Microsoft CSE. (n.d.). Correlation IDs. Code With Engineering Playbook. https://microsoft.github.io/code-with-engineering-playbook/observability/correlation-id/
  • Microsoft CSE. (n.d.). Logs vs Metrics vs Traces. Code With Engineering Playbook. https://microsoft.github.io/code-with-engineering-playbook/observability/log-vs-metric-vs-trace/
  • Microsoft CSE. (n.d.). Observability in Microservices. Code With Engineering Playbook. https://microsoft.github.io/code-with-engineering-playbook/observability/microservices/
  • Myers, G. J., Sandler, C., & Badgett, T. (2011). The art of software testing (3rd ed.). Wiley.
  • Newman, S. (2021). Building microservices (2nd ed.). O'Reilly Media.
  • Nottingham, M., & Wilde, E. (2017). RFC 8288: Web linking. IETF. https://www.rfc-editor.org/rfc/rfc8288
  • Nygard, M. T. (2018). Release it!: Design and deploy production-ready software (2nd ed.). Pragmatic Bookshelf.
  • OpenTelemetry. (n.d.). OpenTelemetry specification. https://opentelemetry.io/docs/specs/
  • Osherove, R. (2013). The art of unit testing (2nd ed.). Manning.
  • PEP 544 - Protocols: Structural subtyping (static duck typing). (2019). Python Software Foundation. https://peps.python.org/pep-0544/
  • Palermo, J. (2008, August 14). The Onion Architecture: Part 3. Programming with Palermo. https://jeffreypalermo.com/2008/08/the-onion-architecture-part-3/
  • Palermo, J. (2008, July 29). The Onion Architecture: Part 1. Programming with Palermo. https://jeffreypalermo.com/2008/07/the-onion-architecture-part-1/
  • Palermo, J. (2008, July 31). The Onion Architecture: Part 2. Programming with Palermo. https://jeffreypalermo.com/2008/07/the-onion-architecture-part-2/
  • Palermo, J. (2013, August 12). Onion Architecture, Part 4, after four years. Programming with Palermo. https://jeffreypalermo.com/2013/08/onion-architecture-part-4-after-four-years/
  • Papazoglou, M. P. (2003). Service-oriented computing: Concepts, characteristics and directions. Proceedings of the Fourth International Conference on Web Information Systems Engineering, 3-12.
  • Parnas, D. L. (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12), 1053-1058.
  • Pautasso, C., Zimmermann, O., & Leymann, F. (2008). RESTful web services vs. "big" web services. Proceedings of the 17th International Conference on World Wide Web, 805-814.
  • Pryce, N., & Freeman, S. (2009). Growing object-oriented software, guided by tests. Addison-Wesley.
  • Pyroscope. (n.d.). Pyroscope continuous profiling. https://pyroscope.io/
  • Richardson, C. (2019). Microservices patterns. Manning.
  • Richardson, L., & Ruby, S. (2007). RESTful web services. O'Reilly Media.
  • Ritchie, D. M. (1993). The development of the C language. ACM SIGPLAN Notices, 28(3), 201-208.
  • Robinson, I., Webber, J., & Eifrem, E. (2015). Graph databases (2nd ed.). O'Reilly Media.
  • Rose, S., Borchert, O., Mitchell, S., & Connelly, S. (2020). Zero trust architecture (NIST Special Publication 800-207). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.SP.800-207
  • Seemann, M. (2011). Dependency injection in .NET. Manning.
  • Sigelman, B. H., Barroso, L. A., Burrows, M., Stephenson, P., Plakal, M., Beaver, D., Jaspan, S., & Shanbhag, C. (2010). Dapper, a large-scale distributed systems tracing infrastructure. Google Research. https://research.google/pubs/dapper-a-large-scale-distributed-systems-tracing-infrastructure/
  • Skelton, M., & Pais, M. (2019). Team topologies. IT Revolution.
  • Stevens, W. P., Myers, G. J., & Constantine, L. L. (1974). Structured design. IBM Systems Journal, 13(2), 115-139.
  • Stone, B. (2013). The everything store: Jeff Bezos and the age of Amazon. Little, Brown and Company.
  • Sutter, H. (2005). Exceptional C++ style. Addison-Wesley.
  • Sutter, H., & Alexandrescu, A. (2004). C++ coding standards: 101 rules, guidelines, and best practices. Addison-Wesley.
  • The mypy team. (n.d.). mypy documentation. https://mypy.readthedocs.io/
  • U.S. Department of Defense. (2022). Department of Defense zero trust reference architecture (Version 2.0).
  • Vernon, V. (2013). Implementing domain-driven design. Addison-Wesley.
  • Vogels, W. (2009). Eventually consistent. Communications of the ACM, 52(1), 40-44.
  • W3C. (2021). Trace Context. https://www.w3.org/TR/trace-context/
  • Wirth, N. (1971). Program development by stepwise refinement. Communications of the ACM, 14(4), 221-227.
  • Yegge, S. (2011, October). Stevey's Google Platforms Rant [Public repost]. https://gist.github.com/chitchcock/1281611
  • Young, G. (2015). A decade of DDD, CQRS, event sourcing. Leanpub.
  • protobuf.dev. (2024). Protocol Buffers language guide. https://protobuf.dev/programming-guides/proto3/