Overview Aotearoa Research Science
In this branch: Foundations Python Rust AI & IT Ecosystem References Readme
Research · Computer Science

Bibliography & References

All sources cited across this reference site, formatted in APA 7th edition style. DOIs and stable URLs are provided where available.

Bibliography

Computer Science Foundations

  1. Turing, A. M. (1936). On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, s2-42(1), 230–265. https://doi.org/10.1112/plms/s2-42.1.230
  2. Shannon, C. E. (1948). A mathematical theory of communication. The Bell System Technical Journal, 27(3), 379–423. https://doi.org/10.1002/j.1538-7305.1948.tb01338.x
  3. Cook, S. A. (1971). The complexity of theorem-proving procedures. Proceedings of the 3rd Annual ACM Symposium on Theory of Computing (pp. 151–158). ACM. https://doi.org/10.1145/800157.805047
  4. Knuth, D. E. (1997). The art of computer programming, Vol. 1: Fundamental algorithms (3rd ed.). Addison-Wesley. ISBN 978-0-201-89683-1.
  5. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2022). Introduction to algorithms (4th ed.). MIT Press. ISBN 978-0-262-04630-5.
  6. Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2006). Compilers: Principles, techniques, and tools (2nd ed.). Pearson/Addison-Wesley. ISBN 978-0-321-48681-3.
  7. Lattner, C., & Adve, V. (2004). LLVM: A compilation framework for lifelong program analysis and transformation. Proceedings of the International Symposium on Code Generation and Optimization (CGO), 75–86. https://doi.org/10.1109/CGO.2004.1281665
  8. Patterson, D. A., & Hennessy, J. L. (2020). Computer organisation and design RISC-V edition: The hardware/software interface (2nd ed.). Morgan Kaufmann. ISBN 978-0-128-12275-4.
  9. Hennessy, J. L., & Patterson, D. A. (2019). Computer architecture: A quantitative approach (6th ed.). Morgan Kaufmann. ISBN 978-0-128-11906-8.
  10. Tanenbaum, A. S., & Bos, H. (2014). Modern operating systems (4th ed.). Pearson. ISBN 978-0-133-59162-0.
  11. Silberschatz, A., Galvin, P. B., & Gagne, G. (2021). Operating system concepts (10th ed.). Wiley. ISBN 978-1-119-32091-3.
  12. Cerf, V., & Kahn, R. (1974). A protocol for packet network intercommunication. IEEE Transactions on Communications, 22(5), 637–648. https://doi.org/10.1109/TCOM.1974.1092259
  13. Berners-Lee, T., Cailliau, R., Luotonen, A., Nielsen, H. F., & Secret, A. (1994). The World-Wide Web. Communications of the ACM, 37(8), 76–82. https://doi.org/10.1145/179606.179671
  14. Codd, E. F. (1970). A relational model of data for large shared data banks. Communications of the ACM, 13(6), 377–387. https://doi.org/10.1145/362384.362685

Python

  1. van Rossum, G. (1995). Python reference manual (CWI Report CS-R9525). CWI. Retrieved from https://ir.cwi.nl/pub/5007
  2. Beazley, D. (2010). Understanding the Python GIL. PyCon 2010 Proceedings. Atlanta, GA. Retrieved from https://www.dabeaz.com/python/UnderstandingGIL.pdf
  3. Oliphant, T. E. (2007). Python for scientific computing. Computing in Science & Engineering, 9(3), 10–20. https://doi.org/10.1109/MCSE.2007.58
  4. Harris, C. R., Millman, K. J., van der Walt, S. J., et al. (2020). Array programming with NumPy. Nature, 585(7825), 357–362. https://doi.org/10.1038/s41586-020-2649-2
  5. McKinney, W. (2010). Data structures for statistical computing in Python. Proceedings of the 9th Python in Science Conference, 445, 51–56. https://doi.org/10.25080/Majora-92bf1922-00a
  6. Hunter, J. D. (2007). Matplotlib: A 2D graphics environment. Computing in Science & Engineering, 9(3), 90–95. https://doi.org/10.1109/MCSE.2007.55
  7. Pedregosa, F., Varoquaux, G., Gramfort, A., et al. (2011). Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12, 2825–2830. Retrieved from https://jmlr.org/papers/v12/pedregosa11a.html
  8. Paszke, A., Gross, S., Massa, F., et al. (2019). PyTorch: An imperative style, high-performance deep learning library. Advances in Neural Information Processing Systems, 32, 8024–8035. Retrieved from https://arxiv.org/abs/1912.01703
  9. Wolf, T., Debut, L., Sanh, V., et al. (2020). Transformers: State-of-the-art natural language processing. Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, 38–45. https://doi.org/10.18653/v1/2020.emnlp-demos.6

Rust

  1. Matsakis, N. D., & Klock, F. S. (2014). The Rust language. ACM SIGAda Ada Letters, 34(3), 103–104. https://doi.org/10.1145/2692956.2663188
  2. Jung, R., Jourdan, J.-H., Krebbers, R., & Dreyer, D. (2017). RustBelt: Securing the foundations of the Rust programming language. Proceedings of the ACM on Programming Languages, 2(POPL), 1–34. https://doi.org/10.1145/3158154
  3. Klabnik, S., & Nichols, C. (2023). The Rust programming language (2nd ed.). No Starch Press. ISBN 978-1-718-50310-4. Also available at https://doc.rust-lang.org/book/
  4. Blandy, J., Orendorff, J., & Tindall, L. F. S. (2021). Programming Rust: Fast, safe systems development (2nd ed.). O’Reilly Media. ISBN 978-1-492-05259-1.

AI & IT Ecosystem

  1. Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep learning. MIT Press. ISBN 978-0-262-03561-3. Also at https://www.deeplearningbook.org/
  2. Virtanen, P., Gommers, R., Oliphant, T. E., et al. (2020). SciPy 1.0: Fundamental algorithms for scientific computing in Python. Nature Methods, 17(3), 261–272. https://doi.org/10.1038/s41592-019-0686-2
  3. Jung, R., Jourdan, J.-H., Krebbers, R., & Dreyer, D. (2021). Safe systems programming in Rust. Communications of the ACM, 64(4), 144–152. https://doi.org/10.1145/3418295
  4. Mell, P., & Grance, T. (2011). The NIST definition of cloud computing (NIST Special Publication 800-145). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.SP.800-145
  5. Verma, A., Pedrosa, L., Korupolu, M., Oppenheimer, D., Tune, E., & Wilkes, J. (2015). Large-scale cluster management at Google with Borg. Proceedings of the 10th European Conference on Computer Systems (EuroSys). https://doi.org/10.1145/2741948.2741964
  6. McCulloch, W. S., & Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115–133. https://doi.org/10.1007/BF02478259
  7. Rosenblatt, F. (1958). The perceptron: A probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386–408. https://doi.org/10.1037/h0042519
  8. Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533–536. https://doi.org/10.1038/323533a0
  9. LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11), 2278–2324. https://doi.org/10.1109/5.726791
  10. Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. Advances in Neural Information Processing Systems, 25, 1097–1105. Retrieved from NeurIPS Proceedings
  11. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention is all you need. Advances in Neural Information Processing Systems, 30. Retrieved from https://arxiv.org/abs/1706.03762
  12. Brown, T., Mann, B., Ryder, N., et al. (2020). Language models are few-shot learners. Advances in Neural Information Processing Systems, 33, 1877–1901. Retrieved from https://arxiv.org/abs/2005.14165
  13. LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature, 521(7553), 436–444. https://doi.org/10.1038/nature14539
  14. Jouppi, N. P., Young, C., Patil, N., et al. (2017). In-datacenter performance analysis of a tensor processing unit. Proceedings of the 44th Annual International Symposium on Computer Architecture (ISCA), 1–12. https://doi.org/10.1145/3079856.3080246
  15. Kaplan, J., McCandlish, S., Henighan, T., et al. (2020). Scaling laws for neural language models. arXiv preprint arXiv:2001.08361. Retrieved from https://arxiv.org/abs/2001.08361
  16. Hoffmann, J., Borgeaud, S., Mensch, A., et al. (2022). Training compute-optimal large language models. Advances in Neural Information Processing Systems, 35. Retrieved from https://arxiv.org/abs/2203.15556
  17. Ouyang, L., Wu, J., Jiang, X., et al. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems, 35, 27730–27744. Retrieved from https://arxiv.org/abs/2203.02155
  18. Sculley, D., Holt, G., Golovin, D., et al. (2015). Hidden technical debt in machine learning systems. Advances in Neural Information Processing Systems, 28. Retrieved from NeurIPS Proceedings
  19. Goodfellow, I. J., Shlens, J., & Szegedy, C. (2015). Explaining and harnessing adversarial examples. Proceedings of the International Conference on Learning Representations (ICLR 2015). Retrieved from https://arxiv.org/abs/1412.6572
  20. Bai, Y., Jones, A., Ndousse, K., et al. (2022). Training a helpful and harmless assistant with reinforcement learning from human feedback. arXiv preprint arXiv:2204.05862. Retrieved from https://arxiv.org/abs/2204.05862

Further Reading & Textbooks

  1. Sipser, M. (2012). Introduction to the theory of computation (3rd ed.). Cengage Learning. ISBN 978-1-133-18779-0. — Definitive undergraduate text on computability and complexity theory.
  2. Lamport, L. (1978). Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, 21(7), 558–565. https://doi.org/10.1145/359545.359563 — Foundational distributed systems paper introducing logical clocks.
  3. Brewer, E. (2000). Towards robust distributed systems [Keynote]. Proceedings of the 19th Annual ACM Symposium on Principles of Distributed Computing (PODC). — Introduced the CAP theorem (Consistency, Availability, Partition tolerance).
  4. Dean, J., & Ghemawat, S. (2004). MapReduce: Simplified data processing on large clusters. Proceedings of the 6th USENIX Symposium on Operating Systems Design and Implementation (OSDI), 137–150. Retrieved from https://research.google/pubs/pub62/
  5. Hochreiter, S., & Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735–1780. https://doi.org/10.1162/neco.1997.9.8.1735
  6. Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of deep bidirectional transformers for language understanding. Proceedings of NAACL-HLT 2019, 4171–4186. Retrieved from https://arxiv.org/abs/1810.04805
  7. Dijkstra, E. W. (1968). Go to statement considered harmful. Communications of the ACM, 11(3), 147–148. https://doi.org/10.1145/362929.362947
  8. Rivest, R. L., Shamir, A., & Adleman, L. (1978). A method for obtaining digital signatures and public-key cryptosystems. Communications of the ACM, 21(2), 120–126. https://doi.org/10.1145/359340.359342
  9. Russell, S., & Norvig, P. (2020). Artificial intelligence: A modern approach (4th ed.). Pearson. ISBN 978-0-134-61099-3. — The standard AI textbook covering search, knowledge representation, planning, learning, and perception.
  10. Dreyfus, H. L. (1972). What computers can’t do: A critique of artificial reason. MIT Press. — Philosophical critique of AI; historically important for understanding the field’s limitations and the debates that shaped its development.

Standards, RFCs & Technical Reports

  1. Postel, J. (1981). Transmission control protocol (RFC 793). IETF. https://www.rfc-editor.org/rfc/rfc793
  2. Fielding, R. T., & Reschke, J. (2014). Hypertext Transfer Protocol (HTTP/1.1): Message syntax and routing (RFC 7230). IETF. https://www.rfc-editor.org/rfc/rfc7230
  3. Bishop, M. (Ed.). (2022). HTTP/3 (RFC 9114). IETF. https://www.rfc-editor.org/rfc/rfc9114
  4. National Institute of Standards and Technology. (2024). Module-lattice-based key-encapsulation mechanism standard (FIPS 203). U.S. Department of Commerce. https://doi.org/10.6028/NIST.FIPS.203
  5. ISO/IEC. (2017). Information technology — Programming languages — C (ISO/IEC 9899:2018). ISO.
  6. The Rust Reference. (2024). The Rust reference. The Rust Project. https://doc.rust-lang.org/reference/
  7. Python Software Foundation. (2024). Python language reference, version 3.13. https://docs.python.org/3/reference/