Bibliography
Every work cited anywhere in this repository, once. The text cites Author Year; the key column matches it.
| Key | Citation | Link |
|---|---|---|
| Abadi 2012 | Abadi (2012). Consistency tradeoffs in modern distributed database system design: CAP is only part of the story. IEEE Computer 45(2), 37-42. Author copy read: first page and the PACELC section | https://doi.org/10.1109/mc.2012.33 |
| Abrahamsson 2010 | Abrahamsson, Babar, Kruchten (2010). Agility and architecture: can they coexist? IEEE Software. Introduction read in a search summary; abstract not reached in full | https://doi.org/10.1109/ms.2010.36 |
| Abrial 2010 | Abrial (2010). Modeling in Event-B: system and software engineering. Cambridge University Press. Book not opened | https://doi.org/10.1017/cbo9781139195881 |
| ADR 2026 | ADR organisation (undated, read 2026). adr.github.io: architectural decision records (definitions, templates, tooling) | https://adr.github.io/ |
| Aghajani 2019 | Aghajani, Nagy, Vega-Marquez, Linares-Vasquez, Moreno, Bavota, Lanza (2019). Software documentation issues unveiled. ICSE | https://doi.org/10.1109/ICSE.2019.00122 |
| Aghajani 2020 | Aghajani, Nagy, Linares-Vasquez, Moreno, Bavota, Lanza, Shepherd (2020). Software documentation: the practitioners' perspective. ICSE | https://doi.org/10.1145/3377811.3380405 |
| Ahmeti 2024 | Ahmeti, Linder, Groner, Wohlrab (2024). Architecture decision records in practice: an action research study. ECSA, Lecture Notes in Computer Science | https://doi.org/10.1007/978-3-031-70797-1_22 |
| Alexeeva 2016 | Alexeeva, Perez-Palacin, Mirandola (2016). Design decision documentation: a literature overview. ECSA, Lecture Notes in Computer Science. Title and venue only | https://doi.org/10.1007/978-3-319-48992-6_6 |
| Alharbi 2025 | Alharbi et al. (2025). Automatic code generation techniques: a systematic literature review. Automated Software Engineering 33(1), article 4 (online 2025-09-12, print 2026-05). Full text read | https://doi.org/10.1007/s10515-025-00551-3 |
| Alhazmi 2026 | Alhazmi (2026). Empirical studies on UML sequence diagrams in education: a systematic literature review. ITiCSE | https://doi.org/10.1145/3803400.3809381 |
| Alquraan 2018 | Alquraan, Takruri, Alfatafta, Al-Kiswany (2018). An analysis of network-partitioning failures in cloud systems. OSDI | https://www.usenix.org/conference/osdi18/presentation/alquraan |
| Amazon 2021 | Bryar, Carr (2021). Working Backwards, excerpt published by Amazon: the PR/FAQ and Working Backwards. The six-page narrative was read only in secondary descriptions | https://www.aboutamazon.com/news/workplace/an-insider-look-at-amazons-culture-and-processes |
| Ameller 2013 | Ameller, Ayala, Cabot, Franch (2013). Non-functional requirements in architectural decision making. IEEE Software. Located only: no abstract reached | https://doi.org/10.1109/ms.2012.176 |
| Andrzejewska 2015 | Andrzejewska, Stolińska, Błasiak (2015). Eye-tracking verification of the strategy used to analyse algorithms expressed in a flowchart and pseudocode. Interactive Learning Environments | https://doi.org/10.1080/10494820.2015.1073746 |
| Andrzejewska 2020 | Andrzejewska et al. (2020). Development of program comprehension skills by novice programmers: longitudinal eye tracking studies. Informatics in Education 19(4), 521-541 | https://doi.org/10.15388/infedu.2020.23 |
| Andrzejewska 2022 | Andrzejewska, Stolińska (2022). Do structured flowcharts outperform pseudocode? Evidence from eye movements. IEEE Access 10, 132965-132975 | https://doi.org/10.1109/access.2022.3230981 |
| AQA 2023 | AQA (2023). AS and A-level Computer Science (7516, 7517) specification, version 1.6. | https://filestore.aqa.org.uk/resources/computing/specifications/AQA-7516-7517-SP-2015.PDF |
| AQA 2024 | AQA (2024). Notes and guidance: pseudo-code, for GCSE Computer Science 8525/1 | https://filestore.aqa.org.uk/resources/computing/AQA-8525-NG-PC.PDF |
| Arc42 2026a | arc42 project (undated, read 2026). arc42-template. Repository page, 1,315 stars on 2026-10-28 | https://github.com/arc42/arc42-template |
| Arc42 2026b | arc42 (undated, read 2026). arc42 documentation, section 9: architecture decisions | https://docs.arc42.org/section-9/ |
| Arisholm 2006 | Arisholm, Briand, Hove, Labiche (2006). The impact of UML documentation on software maintenance: an experimental evaluation. IEEE TSE | https://doi.org/10.1109/TSE.2006.59 |
| Attentive 2026 | Attentive engineering (2026-07-06). RFC process for teams. Company post | https://tech.attentive.com/articles/rfc-process-for-teams |
| Aurum 2002 | Aurum, Petersson, Wohlin (2002). State-of-the-art: software inspections after 25 years. Software Testing, Verification and Reliability | https://doi.org/10.1002/stvr.243 |
| AWS 2026 | Amazon Web Services. AWS Architecture Icons | https://aws.amazon.com/architecture/icons/ |
| AWS 2026b | AWS networking best practices: diagram conventions | https://aws.github.io/aws-networking-best-practices/community/conventions/ |
| AWS 2026c | AWS (undated, read 2026). AWS Prescriptive Guidance: architectural decision records, ADR process | https://docs.aws.amazon.com/prescriptive-guidance/latest/architectural-decision-records/adr-process.html |
| AWS 2026d | Amazon Web Services (read 2026-10-29). The pillars of the AWS Well-Architected Framework. Documentation page, six pillars | https://docs.aws.amazon.com/wellarchitected/latest/framework/the-pillars-of-the-framework.html |
| AWS 2026p | Amazon Web Services (page read 2026-10-29). AWS Well-Architected: framework overview, six pillars (a vendor's account of its own framework) | https://aws.amazon.com/architecture/well-architected/ |
| Azure Patterns 2026 | Microsoft (page updated 2026-10-23, read 2026-10-29). Cloud design patterns, Azure Architecture Center (44 patterns in the catalog table) | https://learn.microsoft.com/en-us/azure/architecture/patterns/ |
| Baabad 2020 | Baabad, Zulzalil, Hassan, Baharom (2020). Software architecture degradation in open source software: a systematic literature review. IEEE Access. Full text read (open access) | https://doi.org/10.1109/ACCESS.2020.3024671 |
| Babar 2004 | Babar, Gorton (2004). Comparison of scenario-based software architecture evaluation methods. APSEC. Full text read (University of Limerick repository copy) | https://doi.org/10.1109/APSEC.2004.38 |
| Back 1998 | Back, von Wright (1998). Refinement calculus: a systematic introduction. Springer. Book not opened | https://doi.org/10.1007/978-1-4612-1674-2 |
| Backstage 2020 | Spotify (2020). Announcing TechDocs, the docs-like-code plugin of Backstage. Project blog, 8 September 2020 | https://backstage.io/blog/2020/09/08/announcing-tech-docs |
| Bailis 2012 | Bailis, Venkataraman, Franklin, Hellerstein, Stoica (2012). Probabilistically bounded staleness for practical partial quorums. PVLDB 5(8), 776-787. Full text read | https://doi.org/10.14778/2212351.2212359 |
| Bailis 2014 | Bailis, Kingsbury (2014). The network is reliable. Communications of the ACM 57(9), 48-55. The article was not reached; the companion post by the same authors was read. Open copy: https://aphyr.com/posts/288-the-network-is-reliable | https://doi.org/10.1145/2643130 |
| Baldassarre 2019 | Baldassarre, Caivano, Romano, Scanniello (2019). Software models for source code maintainability: a systematic literature review. SEAA | https://doi.org/10.1109/SEAA.2019.00047 |
| Baldwin 2000 | Baldwin, Clark (2000). Design Rules, volume 1: the power of modularity. MIT Press. Book, not opened | https://doi.org/10.7551/mitpress/2366.001.0001 |
| Baltes 2014 | Baltes, Diehl (2014). Sketches and diagrams in practice. FSE | https://doi.org/10.1145/2635868.2635891 |
| Basili 1996 | Basili, Green, Laitenberger, Lanubile, Shull, Sorumgard, Zelkowitz (1996). The empirical investigation of perspective-based reading. Empirical Software Engineering | https://doi.org/10.1007/bf00368702 |
| Basili 1996b | Basili, Briand, Melo (1996). A validation of object-oriented design metrics as quality indicators. IEEE TSE. Abstract read | https://doi.org/10.1109/32.544352 |
| Bass 2021 | Bass, Clements, Kazman (2021). Software Architecture in Practice, 4th ed. Addison-Wesley. Book, not opened; publisher page read | https://www.informit.com/store/software-architecture-in-practice-9780136886099 |
| Bauer 2019 | Bauer, Siegmund, Peitek, Hofmeister, Apel (2019). Indentation: simply a matter of style or support for program comprehension? ICPC | https://doi.org/10.1109/ICPC.2019.00033 |
| Beg 2025 | Beg, O'Donoghue, Monahan (2025). A short survey on formalising software requirements using large language models. Preprint; abstract read | https://arxiv.org/abs/2506.11874 |
| Bellomo 2015 | Bellomo, Gorton, Kazman (2015). Toward agile architecture: insights from 15 years of ATAM data. IEEE Software. Abstract read | https://doi.org/10.1109/ms.2015.35 |
| Bennedsen 2008 | Bennedsen, Caspersen (2008). Abstraction ability as an indicator of success for learning computing science? ICER. Full text read; the finding was first read in Liu 2024b | https://doi.org/10.1145/1404520.1404523 |
| Berry 2003 | Berry, Tichy (2003). Comments on "Formal methods application: an empirical tale of software development". IEEE Transactions on Software Engineering 29(6), 567-571. Read on an author's university page | http://se.math.uwaterloo.ca/~dberry/FTP_SITE/reprints.journals.conferences/BerryTichy2003CommentsEmpirical.pdf |
| Bertholf 2000 | Bertholf (2000). Comprehension of literate programs by novice and intermediate programmers. Thesis, Portland State University (not read) | https://doi.org/10.15760/etd.6456 |
| Besker 2018 | Besker, Martini, Bosch (2018). Managing architectural technical debt: a unified model and systematic literature review. Journal of Systems and Software 135. Abstract read in a search summary (secondary) | https://doi.org/10.1016/J.JSS.2017.09.025 |
| Beyer 2016 | Beyer, Jones, Petoff, Murphy (eds.) (2016). Site Reliability Engineering. O'Reilly; read: chapter on postmortem culture by Lunney and Lueder, edited by O'Connor (page footer shows copyright 2017) | https://sre.google/sre-book/postmortem-culture/ |
| Bhat 2020 | Bhat, Shumaiev, Hohenstein, Biesdorf, Matthes (2020). The evolution of architectural decision making as a key focus area of software architecture research: a semi-systematic literature study. ICSA. Abstract only | https://doi.org/10.1109/icsa47634.2020.00015 |
| Bitwarden 2026 | Bitwarden (undated, read 2026). Contributing documentation: architectural decision records | https://contributing.bitwarden.com/architecture/adr/ |
| Blackwell 2003 | Blackwell, Green (2003). Notational systems: the cognitive dimensions of notations framework. In HCI Models, Theories, and Frameworks | https://doi.org/10.1016/B978-155860808-5/50005-8 |
| Blinowski 2022 | Blinowski, Ojdowska, Przybylek (2022). Monolithic vs. microservice architecture: a performance and scalability evaluation. IEEE Access. Abstract read | https://doi.org/10.1109/access.2022.3152803 |
| Bloch 2006 | Bloch (2006). How to design a good API and why it matters. OOPSLA Companion, 506-507. Full text read | https://doi.org/10.1145/1176617.1176622 |
| Boehm 2008 | Boehm, Valerdi, Honour (2008). The ROI of systems engineering: some quantitative results for software-intensive systems. Systems Engineering 11(3). Abstract read (Crossref) | https://doi.org/10.1002/sys.20096 |
| Boehm-Davis 1983 | Boehm-Davis (1983). Representation of information in software documentation. General Electric technical report GEC/DIS/TR-83-388200-8 | https://archive.org/details/DTIC_ADA131470 |
| Bogli 2024 | Bögli, Lerena, Tsigkanos, Kehrer (2024). A systematic literature review on a decade of industrial TLA+ practice. Springer LNCS | https://doi.org/10.1007/978-3-031-76554-4_2 |
| Bornholt 2021 | Bornholt, Joshi, Astrauskas, Cully and others (2021). Using lightweight formal methods to validate a key-value storage node in Amazon S3. SOSP. Author copy read (a company's report on itself). Open copy: https://www.cs.utexas.edu/~bornholt/papers/shardstore-sosp21.pdf | https://doi.org/10.1145/3477132.3483540 |
| Borowa 2023 | Borowa, Lewanczyk, Stpiczynska, Stradomski, Zalewski (2023). What rationales drive architectural decisions? An empirical inquiry. ECSA | arXiv:2309.14164 |
| Bratthall 2000 | Bratthall, Johansson, Regnell (2000). Is a design rationale vital when predicting change impact? A controlled experiment on software architecture evolution. PROFES, LNCS 1840 | https://doi.org/10.1007/978-3-540-45051-1_14 |
| Brewer 2000 | Brewer (2000-07-19). Towards robust distributed systems. PODC keynote slides, 12 pages | https://people.eecs.berkeley.edu/~brewer/cs262b-2004/PODC-keynote.pdf |
| Brewer 2012 | Brewer (2012). CAP twelve years later: how the rules have changed. IEEE Computer 45(2), 23-29. Read in the republication of 2012-05-30 | https://doi.org/10.1109/mc.2012.37 |
| Briand 2000 | Briand, Wust, Daly, Porter (2000). Exploring the relationships between design measures and software quality in object-oriented systems. Journal of Systems and Software. Abstract read in a summary (secondary); volume 51, pages 245-273 from a record | https://doi.org/10.1016/s0164-1212(99)00102-8 |
| Brooke 1980 | Brooke (1980). An experimental study of flowcharts as an aid to identification of procedural faults. Ergonomics | https://doi.org/10.1080/00140138008924752 |
| Brooker 2025 | Brooker, Desai (2025). Systems correctness practices at Amazon Web Services. Communications of the ACM 68(6), 38-42 (Queue version 2024). Full text read | https://doi.org/10.1145/3729175 |
| Brown 2018 | Brown (2018). The C4 model for software architecture. InfoQ, 25 June 2018 | https://www.infoq.com/articles/C4-architecture-model/ |
| Brown 2021 | Brown (2021). Diagrams as code 2.0. GOTO Copenhagen, session page with abstract (the talk itself was not watched) | https://gotopia.tech/sessions/1929/diagrams-as-code-2-0 |
| Brown 2026a | Brown (undated, read 2026). The C4 model for visualising software architecture. Official site | https://c4model.com/ |
| Brown 2026b | Brown (undated, read 2026). The C4 model: diagram notation | https://c4model.com/diagrams/notation |
| Brown 2026c | Brown (undated, read 2026). C4 model: frequently asked questions. Official site | https://c4model.com/faq |
| Brown 2026d | Brown (undated, read 2026). The C4 model: diagram review checklist | https://c4model.com/diagrams/checklist |
| Buchgeher 2023 | Buchgeher, Schoberl, Geist, Dorninger, Haindl, Weinreich (2023). Using architecture decision records in open source projects: an MSR study on GitHub. IEEE Access 11 | https://doi.org/10.1109/access.2023.3287654 |
| Buckingham Shum 1994 | Buckingham Shum, Hammond (1994). Argumentation-based design rationale: what use at what cost? International Journal of Human-Computer Studies. Title and venue only | https://doi.org/10.1006/ijhc.1994.1029 |
| Budgen 2011 | Budgen, Burn, Brereton, Kitchenham et al. (2011). Empirical evidence about the UML: a systematic literature review. Software: Practice and Experience 41 | https://doi.org/10.1002/spe.1009 |
| Byelas 2006 | Byelas, Telea (2006). Visualization of areas of interest in software architecture diagrams. SoftVis | https://doi.org/10.1145/1148493.1148509 |
| ByteByteGo 2023 | ByteByteGo (repository created 2023-09-18). System design 101: 90,808 stars on 2026-10-29. Count only; not read | https://github.com/ByteByteGoHq/system-design-101 |
| Cabo 2018 | Cabo (2018). Effectiveness of flowcharting as a scaffolding tool to learn Python. Frontiers in Education Conference | https://doi.org/10.1109/FIE.2018.8658891 |
| Caine 1975 | Caine, Gordon (1975). PDL: a tool for software design. AFIPS National Computer Conference | https://doi.org/10.1145/1499949.1499995 |
| Cambridge 2024 | Cambridge University Press and Assessment (2024). Pseudocode guide for teachers, AS and A Level Computer Science 9618, exams 2027-2029 | https://www.cambridgeinternational.org/Images/721401-2027-2029-pseudocode-guide.pdf |
| Capilla 2016 | Capilla, Jansen, Tang, Avgeriou, Babar (2016). 10 years of software architecture knowledge management: practice and future. Journal of Systems and Software | https://doi.org/10.1016/j.jss.2015.08.054 |
| Casalnuovo 2015 | Casalnuovo, Devanbu, Oliveira, Filkov, Ray (2015). Assert use in GitHub projects. ICSE. Abstract and introduction read | https://doi.org/10.1109/icse.2015.88 |
| Cataldo 2008 | Cataldo, Herbsleb, Carley (2008). Socio-technical congruence: a framework for assessing the impact of technical and work dependencies on software development productivity. ESEM. Summary line read (secondary); abstract not reached | https://doi.org/10.1145/1414004.1414008 |
| Cataldo 2013 | Cataldo, Herbsleb (2013). Coordination breakdowns and their impact on development productivity and software failures. IEEE TSE. Abstract read in a search summary (secondary) | https://doi.org/10.1109/tse.2012.32 |
| Cepeda Porras 2010 | Cepeda Porras, Guéhéneuc (2010). An empirical study on the efficiency of different design pattern representations in UML class diagrams. Empirical Software Engineering | https://doi.org/10.1007/s10664-009-9125-9 |
| Cervantes 2016 | Cervantes, Kazman (2016). Designing Software Architectures: a practical approach (ADD 3.0). Addison-Wesley. Book, not opened; publisher page read | https://www.informit.com/store/designing-software-architectures-a-practical-approach-9780134390789 |
| Chakarov 2025 | Chakarov et al., Amazon (2025). Formally verified cloud-scale authorization. ICSE. Owner reporting on its own system; abstract and text read | https://www.amazon.science/publications/formally-verified-cloud-scale-authorization |
| Chatlatanagulchai 2026 | Chatlatanagulchai, Li, Kashiwa, Reid, Thonglek, Leelaprute, Rungsawang, Manaskasemsak, Adams, Hassan, Iida (2026). Agent READMEs: an empirical study of context files for agentic coding. Preprint, version 2 of 2026-08-09 (first 2025-11-17) | arXiv:2511.12884 |
| Chen 2026 | Chen, Xu, Chen, Cao, Wu, Cheung (2026). Can emulating semantic translation help LLMs with code translation? A study based on pseudocode. ACM Transactions on Software Engineering and Methodology | https://doi.org/10.1145/3790101 |
| Cheng 2026 | Cheng, Tang, Ma, Hackett, He, Su, Beschastnikh, Huang, Ma, Xu (2026). SysMoBench: evaluating AI on formally modeling complex real-world systems. Preprint, v3 2026-01-28; abstract only | https://arxiv.org/abs/2509.23130 |
| Cherubini 2007 | Cherubini et al. (2007). Let's go to the whiteboard. CHI | https://doi.org/10.1145/1240624.1240714 |
| Chida 2024 | Chida et al. (2024). WIP: how to improve student comprehension of pseudocode reading and writing. Frontiers in Education Conference | https://doi.org/10.1109/fie61694.2024.10893510 |
| Chotisarn 2020 | Chotisarn, Merino, Zheng, Lonapalawong, Zhang, Xu, Chen (2020). A systematic literature review of modern software visualization. Journal of Visualization 23, 539-558 | https://doi.org/10.1007/s12650-020-00647-w |
| Cirstea 2024 | Cirstea, Kuppe, Loillier, Merz (2024). Validating traces of distributed programs against TLA+ specifications. SEFM (arXiv 2404.16075). Forward snowball; abstract read | https://arxiv.org/abs/2404.16075 |
| Claessen 2000 | Claessen, Hughes (2000). QuickCheck: a lightweight tool for random testing of Haskell programs. ICFP, ACM SIGPLAN Notices. Full text read | https://doi.org/10.1145/357766.351266 |
| Clements 2010 | Clements, Bachmann, Bass, Garlan, Ivers, Little, Merson, Nord, Stafford (2010). Documenting Software Architectures: Views and Beyond, 2nd ed. Addison-Wesley | https://www.sei.cmu.edu/library/documenting-software-architectures-views-and-beyond-second-edition/ |
| Coffman 2026 | Coffman et al. (2026). Comparing student achievement, attitudes, and behaviors with RAPTOR and Python. ACM Transactions on Computing Education | https://doi.org/10.1145/3815177 |
| Colfer 2016 | Colfer, Baldwin (2016). The mirroring hypothesis: theory, evidence, and exceptions. Industrial and Corporate Change. Full text read (open access) | https://doi.org/10.1093/icc/dtw027 |
| Collberg 2016 | Collberg, Proebsting (2016). Repeatability in computer systems research. Communications of the ACM 59(3), 62-69. Numbers read in a summary of the 2013 technical report | https://doi.org/10.1145/2812803 |
| College Board 2025 | College Board (2025). AP Computer Science Principles exam reference sheet | https://apcentral.collegeboard.org/media/pdf/ap-computer-science-principles-exam-reference-sheet.pdf |
| Conklin 1988 | Conklin, Begeman (1988). gIBIS: a hypertext tool for exploratory policy discussion. ACM conference on computer-supported cooperative work | https://doi.org/10.1145/62266.62278 |
| Conway 1968 | Conway (1968). How do committees invent? Datamation, April 1968. Reprint on the author's site, read | https://www.melconway.com/Home/Committees_Paper.html |
| Cormen 2003 | Cormen (2003). Using the clrscode package in LaTeX 2e. Guide to typesetting the pseudocode of Introduction to Algorithms, 2nd edition | https://www.cs.dartmouth.edu/~thc/clrscode/clrscode.pdf |
| Costa 2025 | Costa, Fontão, Constantinou (2025). Building the landing zone for site reliability engineering: a multivocal literature review. SBES, 93-103. Open copy: abstract and method read. Open copy: https://sol.sbc.org.br/index.php/sbes/article/download/36989/36774 | https://doi.org/10.5753/sbes.2025.9772 |
| CS 2012a | "Path to formal methods". Computer Science Stack Exchange, question 386, asked 2012-03; read 2026-10-29 (22 votes, 1876 views, 3 answers). | https://cs.stackexchange.com/questions/386 |
| CS 2013a | "Difference between := and ← in pseudocode". Computer Science Stack Exchange, question 8995, asked 2013-01; read 2026-10-28 (6 votes, 16195 views, 1 answers). | https://cs.stackexchange.com/questions/8995 |
| CS 2015a | "the convention for declaring arrays in pseudocode". Computer Science Stack Exchange, question 42226, asked 2015-05; read 2026-10-28 (8 votes, 79094 views, 2 answers). | https://cs.stackexchange.com/questions/42226 |
| CS 2016a | "on "On the cruelty of really teaching computing science"". Computer Science Stack Exchange, question 54143, asked 2016-02; read 2026-10-29 (35 votes, 3168 views, 2 answers). | https://cs.stackexchange.com/questions/54143 |
| CS 2018a | "What is the most used way to write for-loop as pseudocode?". Computer Science Stack Exchange, question 92792, asked 2018-06; read 2026-10-28 (0 votes, 4274 views, 3 answers). | https://cs.stackexchange.com/questions/92792 |
| CS 2019a | "How does Tarjan's pseudocode work (explained to someone familiar with C or Java)?". Computer Science Stack Exchange, question 103816, asked 2019-02; read 2026-10-28 (41 votes, 7755 views, 2 answers). | https://cs.stackexchange.com/questions/103816 |
| CS 2020a | "Convention of a += operator in pseudocode". Computer Science Stack Exchange, question 129463, asked 2020-08; read 2026-10-28 (1 votes, 2981 views, 1 answers). | https://cs.stackexchange.com/questions/129463 |
| CS 2020b | "Algorithm Design Patterns vs. Algorithm Strategies vs. Algorithm Design Techniques vs. Algorithm Design Paradigms". Computer Science Stack Exchange, question 124090, asked 2020-04; read 2026-10-29 (0 votes, 217 views, 1 answers). | https://cs.stackexchange.com/questions/124090 |
| CS 2023a | "Is there a "Standard Algorithm" language, as used in academic papers?". Computer Science Stack Exchange, question 159015, asked 2023-03; read 2026-10-28 (27 votes, 7669 views, 6 answers). | https://cs.stackexchange.com/questions/159015 |
| CSEd 2017a | "Pseudocode or Flowcharts?". Computer Science Educators Stack Exchange, question 650, asked 2017-06; read 2026-10-28 (9 votes, 6005 views, 5 answers). | https://cseducators.stackexchange.com/questions/650 |
| CSEd 2017b | "Should the first Programming/Algorithms class be taught in pseudo-code?". Computer Science Educators Stack Exchange, question 7, asked 2017-05; read 2026-10-28 (22 votes, 1553 views, 9 answers). | https://cseducators.stackexchange.com/questions/7 |
| CSEd 2017c | "Is there any value in teaching pseudo code?". Computer Science Educators Stack Exchange, question 3713, asked 2017-09; read 2026-10-28 (5 votes, 989 views, 3 answers). | https://cseducators.stackexchange.com/questions/3713 |
| CSEd 2019a | "Is it a good idea to teach algorithm courses using pseudocode instead of a real programming language?". Computer Science Educators Stack Exchange, question 5787, asked 2019-05; read 2026-10-28 (25 votes, 1268 views, 12 answers). | https://cseducators.stackexchange.com/questions/5787 |
| CSEd 2020a | "How useful is English (pseudocode and documentation) in aiding understanding?". Computer Science Educators Stack Exchange, question 6548, asked 2020-09; read 2026-10-28 (3 votes, 243 views, 3 answers). | https://cseducators.stackexchange.com/questions/6548 |
| CSEd 2021a | "Resources for flowchart programming for young, new programmers?". Computer Science Educators Stack Exchange, question 6938, asked 2021-05; read 2026-10-28 (4 votes, 471 views, 3 answers). | https://cseducators.stackexchange.com/questions/6938 |
| CTAN 2026 | CTAN (read 2026). Comprehensive TeX Archive Network: packages algorithm2e, algorithmicx, clrscode | https://ctan.org/pkg/algorithm2e |
| Curtis 1989 | Curtis, Sheppard, Kruesi-Bailey, Bailey, Boehm-Davis (1989). Experimental evaluation of software documentation formats. Journal of Systems and Software (abstract not found; paper not read) | https://doi.org/10.1016/0164-1212%2889%2990019-8 |
| D2 2026 | D2 repository, GitHub (stars read 2026-10-28) | https://github.com/d2lang/d2 |
| Dagenais 2010 | Dagenais, Ossher, Bellamy, Robillard, de Vries (2010). Moving into a new software project landscape. ICSE | https://doi.org/10.1145/1806799.1806842 |
| Davis 2023 | Davis (2023). Pseudocode is not durable. Personal blog | https://emptysqua.re/blog/write-python-not-pseudocode/ |
| Dean 2013 | Dean, Barroso (2013). The tail at scale. Communications of the ACM 56(2), 74-80. Author copy read in full. Open copy: https://www.barroso.org/publications/TheTailAtScale.pdf | https://doi.org/10.1145/2408776.2408794 |
| de Dieu 2022 | de Dieu, Liang, Shahin (2022). How do developers search for architectural information? An industrial survey. ICSA | https://doi.org/10.1109/ICSA53651.2022.00014 , arXiv:2112.10920 |
| de Dieu 2024 | de Dieu, Liang, Shahin, Yang, Li (2024). Mining architectural information: a systematic mapping study. Empirical Software Engineering 29 | https://doi.org/10.1007/s10664-024-10480-6 , arXiv:2212.13179 |
| de Graaf 2016 | de Graaf, Liang, Tang, van Vliet (2016). How organisation of architecture documentation affects architectural knowledge retrieval. Science of Computer Programming | https://doi.org/10.1016/j.scico.2015.10.014 |
| Dehaerne 2022 | Dehaerne et al. (2022). Code generation using machine learning: a systematic review. IEEE Access | https://doi.org/10.1109/ACCESS.2022.3196347 |
| De Luca 2026 | De Luca, Santilli, Amalfitano, Fasolino, Pelliccione (2026). CIAO, Code In Architecture Out: automated software architecture documentation with large language models. ICSA, 201-212 | https://doi.org/10.1109/ICSA66085.2026.00026 , arXiv:2604.08293 |
| de Silva 2012 | de Silva, Balasubramaniam (2012). Controlling software architecture erosion: a survey. Journal of Systems and Software. Abstract read in a search summary (secondary) | https://doi.org/10.1016/j.jss.2011.07.036 |
| Dhar 2024 | Dhar, Vaidhyanathan, Varma (2024). Can LLMs generate architectural design decisions? An exploratory empirical study. ICSA. Abstract read | arXiv:2403.01709 |
| Dietrich 2017 | Dietrich, Pearce, Jezek, Brada (2017). Contracts in the wild: a study of Java programs. ECOOP, LIPIcs 74, article 9. Abstract read | https://doi.org/10.4230/LIPIcs.ECOOP.2017.9 |
| Di Francesco 2018 | Di Francesco, Lago, Malavolta (2018). Migrating towards microservice architectures: an industrial survey. ICSA. Full text read, open copy on the VU Research Portal | https://doi.org/10.1109/icsa.2018.00012 |
| Dijkstra 1975 | Dijkstra (1975). Guarded commands, nondeterminacy and formal derivation of programs. Communications of the ACM. Full text read | https://doi.org/10.1145/360933.360975 |
| Dikici 2018 | Dikici, Turetken, Demirörs (2018). Factors influencing the understandability of process models: a systematic literature review. Information and Software Technology 93, 112-129 | https://doi.org/10.1016/j.infsof.2017.09.001 |
| Ding 2014a | Ding, Liang, Tang, van Vliet (2014). Knowledge-based approaches in software documentation: a systematic literature review. Information and Software Technology | https://doi.org/10.1016/j.infsof.2014.01.008 |
| Ding 2014b | Ding, Liang, Tang, van Vliet, Shahin (2014). How do open source communities document software architecture: an exploratory survey. ICECCS | https://doi.org/10.1109/ICECCS.2014.26 |
| Dobing 2006 | Dobing, Parsons (2006). How UML is used. Communications of the ACM | https://doi.org/10.1145/1125944.1125949 |
| Dobrica 2002 | Dobrica, Niemela (2002). A survey on software architecture analysis methods. IEEE TSE. Abstract read | https://doi.org/10.1109/tse.2002.1019479 |
| docToolchain 2026 | docToolchain project (undated, read 2026). docToolchain: a documentation toolchain focused on software architecture documentation. Repository page, 872 stars on 2026-10-28 | https://github.com/docToolchain/docToolchain |
| DORA 2025 | DORA (page updated 2025-10-20). Capability: loosely coupled teams. DORA research programme | https://dora.dev/capabilities/loosely-coupled-teams/ |
| Dutoit 2006 | Dutoit, McCall, Mistrik, Paech, eds. (2006). Rationale management in software engineering. Springer | https://doi.org/10.1007/3-5403-0998-5 |
| Dzidek 2008 | Dzidek, Arisholm, Briand (2008). A realistic empirical evaluation of the costs and benefits of UML in software maintenance. IEEE TSE | https://doi.org/10.1109/TSE.2008.15 |
| Eichelberger 2009 | Eichelberger, Schmid (2009). Guidelines on the aesthetic quality of UML class diagrams. Information and Software Technology | https://doi.org/10.1016/j.infsof.2009.04.008 |
| Elberzhager 2026 | Elberzhager, Gerbershagen, Ginkel (2026). Using LLMs to evaluate architecture documents: results from a digital marketplace environment. Preprint | arXiv:2601.19693 |
| Ellis 2007 | Ellis, Stylos, Myers (2007). The factory pattern in API design: a usability evaluation. ICSE, 302-312. Full text read, the authors' copy on the CMU Natural Programming page | https://doi.org/10.1109/icse.2007.85 |
| Elm 2012 | Elm, Goldenson (2012). The business case for systems engineering study: results of the systems engineering effectiveness survey. SEI report. Abstract only | https://doi.org/10.21236/ada610517 |
| Emery 2009 | Emery, Hilliard (2009). Every architecture description needs a framework: expressing architecture frameworks using ISO/IEC 42010. WICSA/ECSA | https://doi.org/10.1109/WICSA.2009.5290789 |
| Endres 2023 | Endres, Fakhoury, Chakraborty, Lahiri (2023). Can large language models transform natural language intent into formal method postconditions? Preprint; abstract partly read | https://arxiv.org/abs/2310.01831 |
| Ensmenger 2016 | Ensmenger (2016). The multiple meanings of a flowchart. Information and Culture | https://doi.org/10.1353/lac.2016.0013 |
| Ernst 2015 | Ernst, Bellomo, Ozkaya, Nord, Gorton (2015). Measure it? Manage it? Ignore it? Software practitioners and technical debt. ESEC/FSE. Abstract read (Crossref) | https://doi.org/10.1145/2786805.2786848 |
| Ernst 2023 | Ernst, Robillard (2023). A study of documentation for software architecture. Empirical Software Engineering. Replication package: https://zenodo.org/record/7539493 | https://doi.org/10.1007/s10664-023-10347-2 , arXiv:2305.17286 |
| Esposito 2025 | Esposito, Li, Moreschini, Ahmad, Cerny, Vaidhyanathan et al. (2025). Generative AI for software architecture: applications, trends, challenges, and future directions. Journal of Systems and Software. Abstract read | arXiv:2503.13310 |
| Estler 2014 | Estler, Furia, Nordio, Piccioni, Meyer (2014). Contracts in practice. Formal Methods, Lecture Notes in Computer Science. Abstract read on the preprint (arXiv 1211.4775) | https://doi.org/10.1007/978-3-319-06410-9_17 |
| Evans 2003 | Evans (2003). Domain-Driven Design: tackling complexity in the heart of software. Addison-Wesley. Book, not opened; publisher page read | https://www.informit.com/store/domain-driven-design-tackling-complexity-in-the-heart-of-9780321125217 |
| Fakhoury 2024 | Fakhoury, Naik, Sakkas, Chakraborty, Lahiri (2024). LLM-based test-driven interactive code generation: user study and empirical evaluation. IEEE Transactions on Software Engineering. Abstract read | https://doi.org/10.1109/tse.2024.3428972 |
| Falessi 2006 | Falessi, Cantone, Becker (2006). Documenting design decision rationale to improve individual and team design decision making: an experimental evaluation. ISESE | https://doi.org/10.1145/1159733.1159755 |
| Falessi 2008 | Falessi, Cantone, Kruchten (2008). Value-based design decision rationale documentation: principles and empirical feasibility study. WICSA | https://doi.org/10.1109/wicsa.2008.8 |
| Falessi 2010 | Falessi, Babar, Cantone, Kruchten (2010). Applying empirical software engineering to software architecture: challenges and lessons learned. Empirical Software Engineering 15(3) | https://doi.org/10.1007/s10664-009-9121-0 |
| Falessi 2011 | Falessi, Cantone, Kazman, Kruchten (2011). Decision-making techniques for software architecture design: a comparative survey. ACM Computing Surveys. Abstract read in a search summary (secondary) | https://doi.org/10.1145/1978802.1978812 |
| Farenhorst 2009 | Farenhorst, de Boer (2009). Knowledge management in software architecture: state of the art. In Software Architecture Knowledge Management, 21-38 | https://doi.org/10.1007/978-3-642-02374-3_2 |
| Felleisen 2004 | Felleisen, Findler, Flatt, Krishnamurthi (2004). The structure and interpretation of the computer science curriculum. Journal of Functional Programming. Full text read | https://doi.org/10.1017/s0956796804005076 |
| Fernández-Sáez 2013 | Fernández-Sáez, Genero, Chaudron (2013). Empirical studies concerning the maintenance of UML diagrams and their use in the maintenance of code: a systematic mapping study. Information and Software Technology 55 | https://doi.org/10.1016/j.infsof.2012.12.006 |
| Fernández-Sáez 2014 | Fernández-Sáez, Genero, Caivano, Chaudron (2014). Does the level of detail of UML diagrams affect the maintainability of source code? A family of experiments. Empirical Software Engineering | https://doi.org/10.1007/s10664-014-9354-4 |
| Filho 2019 | Filho, Carneiro, Maciel (2019). A systematic mapping on visual solutions to support the comprehension of software architecture evolution. DMS, 63-74 | https://doi.org/10.18293/dmsviva2019-008 |
| Finney 1996 | Finney (1996). Mathematical notation in formal specification: too difficult for the masses? IEEE Transactions on Software Engineering. Abstract read on a repository page | https://doi.org/10.1109/32.485225 |
| Fisler 2014 | Fisler (2014). The recurring rainfall problem. ICER. Read in a search summary | https://doi.org/10.1145/2632320.2632346 |
| Fonseca 2017 | Fonseca, Zhang, Wang, Krishnamurthy (2017). An empirical study on the correctness of formally verified distributed systems. EuroSys. Named in Lampson 2020; abstract read | https://doi.org/10.1145/3064176.3064183 |
| Ford 2017 | Ford, Parsons, Kua (2017). Building Evolutionary Architectures. Existence and authors read in search listings; publisher not confirmed; not opened. Second edition page | https://www.thoughtworks.com/en-us/insights/books/building-evolutionaryarchitectures-second-edition |
| Forsgren 2018 | Forsgren, Humble, Kim (2018). Accelerate: the science of lean software and DevOps. IT Revolution. Book, not opened; publisher page read | https://itrevolution.com/product/accelerate/ |
| Forum 2026 | Anonymous forum post (undated, read 2026). Transcription of Algorithm E from Knuth, The Art of Computer Programming vol. 1, section 1.1 | https://hn.svelte.dev/item/47271665 |
| Fowler 2015 | Fowler (2015-06-03). Monolith first. martinfowler.com | https://martinfowler.com/bliki/MonolithFirst.html |
| Frazelle 2026 | Frazelle, Cantrill (undated, read 2026). Oxide. RFD 1: requests for discussion | https://rfd.shared.oxide.computer/rfd/0001 |
| Fuchsia 2025 | Fuchsia project (page last updated 2025-02-28). Adding diagrams to documentation | https://fuchsia.dev/docs/contribute/docs/adding-diagrams |
| Furia 2014 | Furia, Meyer, Velder (2014). Loop invariants: analysis, classification, and examples. ACM Computing Surveys. Abstract read on the preprint | https://arxiv.org/abs/1211.4470 |
| Garavel 2020 | Garavel, ter Beek, van de Pol (2020). The 2020 expert survey on formal methods. FMICS, Lecture Notes in Computer Science 12327, 3-69. Open copy read | https://doi.org/10.1007/978-3-030-58298-2_1 |
| Garousi 2019 | Garousi, Felderer, Mäntylä (2019). Guidelines for including grey literature and conducting multivocal literature reviews in software engineering. Information and Software Technology 106, 101-121 | https://doi.org/10.1016/j.infsof.2018.09.006 |
| GDS 2026 | Government Digital Service (page reviewed 2026-03-05). GDS Way: architecture decisions | https://gds-way.digital.cabinet-office.gov.uk/standards/architecture-decisions.html |
| Gebreweld 2023 | Gebreweld (2023). Architecture knowledge representation and communication industry survey. Preprint; 45 architects at one bank. Abstract only | arXiv:2309.11572 |
| Ghemawat 2023 | Ghemawat, Grandl, Petrovic, Whittaker et al. (2023). Towards modern development of cloud applications. HotOS. Abstract read | https://doi.org/10.1145/3593856.3595909 |
| Gilbert 2002 | Gilbert, Lynch (2002). Brewer's conjecture and the feasibility of consistent, available, partition-tolerant web services. ACM SIGACT News 33(2), 51-59. Author copy: abstract and introduction read. Open copy: https://www.comp.nus.edu.sg/~gilbert/pubs/BrewersConjecture-SigAct.pdf | https://doi.org/10.1145/564585.564601 |
| Gill 2011 | Gill, Jain, Nagappan (2011). Understanding network failures in data centers: measurement, analysis, and implications. SIGCOMM. Named in Alquraan 2018; full text read | https://doi.org/10.1145/2018436.2018477 |
| Ginat 2003 | Ginat (2003). The greedy trap and learning from mistakes. SIGCSE. Full text read; the finding was first read in Liu 2024b | https://doi.org/10.1145/611892.611920 |
| GitHub 2022 | GitHub blog (2022). Include diagrams in your Markdown files with Mermaid | https://github.blog/developer-skills/github/include-diagrams-markdown-files-mermaid/ |
| GitHub 2026 | GitHub repository listings and REST search API, queried 2026-10-28: rust-lang/rfcs, python/peps, kubernetes/enhancements, golang/proposal, npryce/adr-tools, adr/madr, joelparkerhenderson/architecture-decision-record, topics adr and architecture-decision-records | https://docs.github.com/en/rest/search/search |
| GitLab 2026 | GitLab (undated, read 2026). Documentation style guide, diagrams and images sections | https://docs.gitlab.com/development/documentation/styleguide/ |
| Gleirscher 2019 | Gleirscher, Foster, Woodcock (2019). New opportunities for integrated formal methods. ACM Computing Surveys. Abstract read | https://doi.org/10.1145/3357231 |
| Gleirscher 2020 | Gleirscher, Marmsoler (2020). Formal methods in dependable systems engineering: a survey of professionals from Europe and North America. Empirical Software Engineering. Abstract read on the preprint (arXiv 1812.08815) | https://doi.org/10.1007/s10664-020-09836-5 |
| Gliffy 2023 | Gliffy (2023). Software architecture documentation: common mistakes and best practices. Vendor blog, 23 February 2023 | https://www.gliffy.com/blog/architecture-documentation-best-practices |
| Gloaguen 2026 | Gloaguen, Mundler, Muller, Raychev, Vechev (2026). Evaluating AGENTS.md: are repository-level context files helpful for coding agents? Preprint | arXiv:2602.11988 |
| Glorfeld 1988 | Glorfeld (1988). A comparison of novice algorithm composition performance using flowcharting or pseudocode as the design tool. Journal of Educational Technology Systems | https://doi.org/10.1080/08886504.1988.10781862 |
| Go 2026b | Go project (undated, read 2026). golang/proposal repository: README, the proposal process | https://github.com/golang/proposal/blob/master/README.md |
| Goldstein 2024 | Goldstein, Cutler, Dickstein, Pierce, Head (2024). Property-based testing in practice. ICSE. Abstract read | https://doi.org/10.1145/3597503.3639581 |
| Goodger 2002 | Goodger, Warsaw, Cannon (2002). PEP 12: sample reStructuredText PEP template | https://peps.python.org/pep-0012/ |
| Google AIP 2025 | Google (AIP-1, created and last updated 2018-08-20; changelog entry 2025-01-09; read 2026-10-29). API Improvement Proposals: purpose and guidelines (the owner's process) | https://google.aip.dev/1 |
| Google Cloud 2024 | Google Cloud (page dated 2024-08-16). Architecture decision records overview, Cloud Architecture Center | https://docs.cloud.google.com/architecture/architecture-decision-records |
| GOV.UK 2025 | Department for Science, Innovation and Technology, Government Digital Service (2025-11-04). Architectural decision record framework. Guidance page; GDS content read in a search summary (secondary) | https://www.gov.uk/government/publications/architectural-decision-record-framework |
| Green 1992 | Green, Petre (1992). When visual programs are harder to read than textual programs. European Conference on Cognitive Ergonomics (ECCE 6) | https://core.ac.uk/works/16724972 |
| Green 1996 | Green, Petre (1996). Usability analysis of visual programming environments: a cognitive dimensions framework. Journal of Visual Languages and Computing | https://doi.org/10.1006/jvlc.1996.0009 |
| Gries 1981 | Gries (1981). The science of programming. Springer. Book not opened | https://doi.org/10.1007/978-1-4612-5983-1 |
| Groher 2015 | Groher, Weinreich (2015). A study on architectural decision-making in context. WICSA | https://doi.org/10.1109/wicsa.2015.27 |
| Guerreiro 2023 | Guerreiro, Amaral, Goulão (2023). Unleashing the power of sound: revisiting the Physics of Notations for modelling with auditory symbols. arXiv preprint | https://arxiv.org/abs/2304.08654 |
| Guessi 2012 | Guessi, Neto, Bianchi, Felizardo, Oquendo, Nakagawa (2012). Architectural description of embedded systems: a systematic review. ISARCS | https://doi.org/10.1145/2304656.2304661 |
| Guessi 2015 | Guessi, Neto, Bianchi, Felizardo, Oquendo, Nakagawa (2015). A systematic literature review on the description of software architectures for systems of systems. ACM SAC, 1433-1440 | https://doi.org/10.1145/2695664.2695795 |
| Gunawi 2014 | Gunawi, Hao, Leesatapornwongsa, Patana-anake, Do, Adityatama, Eliazar, Laksono, Lukman, Martin, Satria (2014). What bugs live in the cloud? A study of 3000+ issues in cloud systems. SoCC. Author copy: abstract and introduction read. Open copy: https://ucare.cs.uchicago.edu/pdf/socc14-cbs.pdf | https://doi.org/10.1145/2670979.2670986 |
| Gunawi 2016 | Gunawi, Hao, Suminto, Laksono, Satria, Adityatama, Eliazar (2016). Why does the cloud stop computing? Lessons from hundreds of service outages. SoCC. Author copy: abstract and root-cause sections read. Open copy: https://ucare.cs.uchicago.edu/pdf/socc16-cos.pdf | https://doi.org/10.1145/2987550.2987583 |
| Gunawi 2018 | Gunawi, Suminto, Sears, Golliher, Sundararaman and others (2018). Fail-slow at scale: evidence of hardware performance faults in large production systems. FAST. Abstract read: 101 reports | https://www.usenix.org/conference/fast18/presentation/gunawi |
| Gundersen 2018 | Gundersen, Kjensmo (2018). State of the art: reproducibility in artificial intelligence. AAAI | https://doi.org/10.1609/aaai.v32i1.11503 |
| Guo 2017 | Guo, Zhang, Wang (2017). What is the further evidence about UML? A systematic literature review. APSEC Workshops | https://doi.org/10.1109/APSECW.2017.28 |
| Gupta 2026 | Gupta, Dhar, Feitosa (2026). Context matters: evaluating context strategies for automated ADR generation using LLMs. Preprint. Abstract only | arXiv:2604.03826 |
| Hackett 2023 | Hackett, Rowe, Kuppe (2023). Understanding inconsistency in Azure Cosmos DB with TLA+. ICSE-SEIP, 1-12 (arXiv 2210.13661, 2022-10-24). Abstract read. Open copy: https://arxiv.org/abs/2210.13661 | https://doi.org/10.1109/icse-seip58684.2023.00006 |
| Hanenberg 2024 | Hanenberg, Morzeck, Gruhn (2024). Indentation and reading time: a randomized control trial on the differences between generated indented and non-indented if-statements. Empirical Software Engineering | https://doi.org/10.1007/s10664-024-10531-y |
| Harhio 2022 | Harhio (2022). Documenting software architecture design decisions in continuous software development: a multivocal literature review. Master's thesis, University of Helsinki. Read in full | http://hdl.handle.net/10138/352074 |
| HashiCorp 2026 | HashiCorp (undated, read 2026). RFC template | https://web.archive.org/web/20250121005611/https://www.hashicorp.com/how-hashicorp-works/articles/rfc-template |
| Hatcliff 2012 | Hatcliff, Leavens, Leino, Müller, Parkinson (2012). Behavioral interface specification languages. ACM Computing Surveys. Abstract read | https://doi.org/10.1145/2187671.2187678 |
| Hebig 2016 | Hebig et al. (2016). The quest for open source projects that use UML. MODELS | https://doi.org/10.1145/2976767.2976778 |
| Heijstek 2011 | Heijstek, Kühne, Chaudron (2011). Experimental analysis of textual and graphical representations for software architecture design. ESEM, 167-176. Result read in its abstract (secondary) | https://doi.org/10.1109/ESEM.2011.25 |
| Helwer 2023 | Helwer (2023). Pseudocode showdown. Personal blog (a practitioner's account) | https://ahelwer.ca/post/2023-03-30-pseudocode/ |
| Hendrix 2002 | Hendrix, Cross, Maghsoodloo (2002). The effectiveness of control structure diagrams in source code comprehension activities. IEEE Transactions on Software Engineering | https://doi.org/10.1109/TSE.2002.1000450 |
| Herbsleb 1999 | Herbsleb, Grinter (1999). Splitting the organization and integrating the code: Conway's law revisited. ICSE. Abstract read in a search summary (secondary) | https://doi.org/10.1145/302405.302455 |
| Hoare 1969 | Hoare (1969). An axiomatic basis for computer programming. Communications of the ACM. Full text read | https://doi.org/10.1145/363235.363259 |
| Hofmeister 2007 | Hofmeister, Kruchten, Nord, Obbink, Ran, America (2007). A general model of software architecture design derived from five industrial approaches. Journal of Systems and Software. Full text read through a library | https://doi.org/10.1016/j.jss.2006.05.024 |
| Hong 2023 | Hong, Zhuge, Chen, Zheng et al. (2023). MetaGPT: meta programming for multi-agent collaborative framework. Preprint, later ICLR 2024. Abstract read | arXiv:2308.00352 |
| Hooker 1994 | Hooker (1994). Needed: an empirical science of algorithms. Operations Research 42(2). Title and venue only; the PDF is a scan with no text layer, so unreadable here | https://doi.org/10.1287/opre.42.2.201 |
| Hooker 1995 | Hooker (1995). Testing heuristics: we have it all wrong. Journal of Heuristics. Full text read | https://doi.org/10.1007/bf02430364 |
| Ho-Quang 2017 | Ho-Quang et al. (2017). Practices and perceptions of UML use in open source projects. ICSE-SEIP | https://doi.org/10.1109/ICSE-SEIP.2017.28 |
| Horner 2006 | Horner, Atwood (2006). Effective design rationale: understanding the barriers. In Rationale management in software engineering (read by title only) | https://doi.org/10.1007/978-3-540-30998-7_3 |
| Houy 2012 | Houy, Fettke, Loos (2012). Understanding understandability of conceptual models: what are we actually talking about? ER, Lecture Notes in Computer Science, 64-77 | https://doi.org/10.1007/978-3-642-34002-4_5 |
| HtDP 2026 | Felleisen, Findler, Flatt, Krishnamurthi (edition dated 2024-11-6 in the page address). How to design programs, second edition, preface. Page read 2026-10-29 | https://web.archive.org/web/20260623072255/https://htdp.org/2024-11-6/Book/part_preface.html |
| Huang 2017 | Huang, Guo, Zhou, Lorch, Dang, Chintalapati, Yao (2017). Gray failure: the Achilles' heel of cloud-scale systems. HotOS, 6 pages. Abstract read | https://doi.org/10.1145/3102980.3103005 |
| Huisman 2020 | Huisman, Gurov, Malkis (2020). Formal methods: from academia to industrial practice, a travel guide. Preprint. Abstract read | https://arxiv.org/abs/2002.07279 |
| Hypothesis 2026 | Hypothesis project (2026). Repository page and PyPI download statistics: 9,114 stars (repository API) and 52,744,281 downloads in the last month (download statistics API), both read 2026-10-29 | https://github.com/HypothesisWorks/hypothesis |
| Hyun 2023 | Hyun, Hurtado (2023). Traceability of architectural design decisions and software artifacts: a systematic mapping study. Foundations of Computing and Decision Sciences 48(4), 401-423. Journal page only | https://doi.org/10.2478/fcds-2023-0018 |
| IcePanel 2023 | IcePanel (2023-02-21). Top 6 mistakes in software architecture diagrams. Company blog | https://icepanel.io/blog/top-6-mistakes-in-software-architecture-diagrams |
| IcePanel 2024 | IcePanel (2024). State of software architecture report 2024. Vendor survey, 96 respondents, 26 November 2024 | https://icepanel.io/blog/state-of-software-architecture-2024 |
| IcePanel 2025 | IcePanel (2025). State of software architecture report 2025. Vendor survey, 75 respondents | https://icepanel.io/blog/state-of-software-architecture-survey-2025 |
| IETF 2014 | Flanagan, Ginoza (2014). RFC 7322: RFC style guide | https://www.rfc-editor.org/rfc/rfc7322 |
| Ince 2012 | Ince, Hatton, Graham-Cumming (2012). The case for open computer programs. Nature 482, 485-488 (a page synopsis was read, not the paper) | https://doi.org/10.1038/nature10836 |
| INCOSE 2023 | INCOSE (2023). INCOSE Systems Engineering Handbook, 5th edition. Wiley, ISBN 978-1-119-81429-0. Not opened; known from listings | https://www.oreilly.com/library/view/incose-systems-engineering/9781119814290/ |
| Islam 2023 | Islam, Hasan, Eisty (2023). Documentation practices in agile software development: a systematic literature review. SERA, 266-273 | https://doi.org/10.1109/sera57763.2023.10197828 , arXiv:2304.07482 |
| ISO 2023b | ISO/IEC/IEEE (2023). 15288: systems and software engineering, system life cycle processes, edition 2, 2023-05. Not opened; clause numbers from the publisher listing | https://www.iso.org/standard/81702.html |
| ISO 2022 | ISO/IEC/IEEE 42010:2022, Software, systems and enterprise: architecture description (second edition; first edition 2011). Concepts, conformance cases and changes as described on the standard's working-group site | http://www.iso-architecture.org/42010/ , http://www.iso-architecture.org/42010/faq.html |
| ISO 2023c | ISO/IEC 25010:2023, Systems and software engineering: product quality model, edition 2. Read in a summary of the standard (nine characteristics), not in the standard | https://iso.org/standard/78176.html |
| ISO 2019 | ISO/IEC/IEEE (2019). 42020: software, systems and enterprise, architecture processes. Not opened; listing says confirmed in 2025 | https://www.iso.org/standard/68982.html |
| Jackson 2002 | Jackson (2002). Alloy: a lightweight object modelling notation. ACM Transactions on Software Engineering and Methodology. Full text read | https://doi.org/10.1145/505145.505149 |
| Jansen 2005 | Jansen, Bosch (2005). Software architecture as a set of architectural design decisions. WICSA | https://doi.org/10.1109/wicsa.2005.61 |
| Jepsen 2026 | Jepsen (page read 2026-10-29). Jepsen analyses: 51 entries for 39 systems, 2013-05-18 to 2026-10-20 (count by the page reader) | https://jepsen.io/analyses |
| Jiang 2023b | Jiang, Dong, Wang, Fang, Shang, Li, Jin, Jiao (2023). Self-planning code generation with large language models. TOSEM (arXiv 2303.06689; abstract read). Linked, not reviewed here | https://doi.org/10.1145/3672456 |
| Jiang 2024 | Jiang, Wang, Shen, Kim, Kim (2024). A survey on large language models for code generation. Preprint. Abstract read | https://arxiv.org/abs/2406.00515 |
| Jin 2025 | Jin, Li, Yang, Zhang, Zeng (2025). Understanding chain-of-thought effectiveness in code generation: an empirical and information-theoretic analysis. Preprint; abstract read | https://arxiv.org/abs/2512.09679 |
| Johnson 2002 | Johnson (2002). A theoretician's guide to the experimental analysis of algorithms. DIMACS Series in Discrete Mathematics and Theoretical Computer Science. Read in full (the author's copy) | https://doi.org/10.1090/dimacs/059/11 |
| Jokste 2024 | Jokste, Kampars (2024). Comprehensible software architecture visualization with C4 model for WRM ecosystem members. ITMS | https://doi.org/10.1109/ITMS64072.2024.10741937 |
| Jongeling 2025 | Jongeling, Strom, Nissen, Kitchen, Carlson (2025). Adopting the C4 model for lightweight architecture modeling: an experience report. SEAA, LNCS | https://doi.org/10.1007/978-3-032-04190-6_24 |
| Julaihi 2026 | Julaihi, Bohari, Che Md Nor, Abdul Talip (2026). Comparative analysis of pseudocode and flowcharts in algorithm development among first-year computer science students. Voice of Academia 22(1), 225-239 | https://doi.org/10.24191/VoA.v22i1.11473 |
| Júnior 2019 | Júnior, Misra, Soares (2019). A systematic mapping study on software architectures description based on ISO/IEC/IEEE 42010:2011. ICCSA, LNCS, 17-30 | https://doi.org/10.1007/978-3-030-24308-1_2 |
| Karsenty 1996 | Karsenty (1996). An empirical evaluation of design rationale documents. CHI | https://doi.org/10.1145/238386.238462 |
| Kashitsyn 2024 | Kashitsyn (2024-09-15). Effective design docs. Blog post | https://mmapped.blog/posts/31-effective-design-docs |
| Katona 2022 | Katona (2022). Measuring cognition load using eye-tracking parameters based on algorithm description tools. Sensors | https://doi.org/10.3390/s22030912 |
| Kaufman 2026 | Kaufman, Brun, Murali, Endres (2026). Programmers are poor and overconfident judges of LLM-generated assertions. Preprint, 2026-07; abstract read | https://arxiv.org/abs/2607.08885 |
| Kazman 2000 | Kazman, Klein, Clements (2000). ATAM: method for architecture evaluation. SEI technical report CMU/SEI-2000-TR-004. Full text read | https://doi.org/10.21236/ada382629 |
| Kazman 2015 | Kazman, Cai, Mo, Feng, Xiao, Haziyev, Fedak, Shapochka (2015). A case study in locating the architectural roots of technical debt. ICSE. Abstract read in a search summary (secondary) | https://doi.org/10.1109/icse.2015.146 |
| Kazman 2016 | Kazman, Goldenson, Monarch, Nichols, Valetto (2016). Evaluating the effects of architectural documentation: a case study of a large scale open source project. IEEE TSE | https://doi.org/10.1109/TSE.2015.2465387 |
| Keertipati 2016 | Keertipati, Licorish, Savarimuthu (2016). Exploring decision-making processes in Python. EASE | https://doi.org/10.1145/2915970.2915993 |
| Khomh 2008 | Khomh, Gueheneuc (2008). Do design patterns impact software quality positively? CSMR. Abstract of the technical report version read in a search summary (secondary) | https://doi.org/10.1109/csmr.2008.4493325 |
| Kiro 2026 | Amazon (2026). Kiro documentation: specs (requirements, design, tasks). Page read 2026-10-29. A vendor's own tool | https://web.archive.org/web/20261023080347/https://kiro.dev/docs/specs/ |
| Kleinberg 2005 | Kleinberg, Tardos (2005). Algorithm design. Pearson. Described by the publisher's page; book not opened | https://www.pearson.com/store/en-us/p/algorithm-design/P200000003259 |
| Kleppmann 2015 | Kleppmann (2015). A critique of the CAP theorem. Preprint, v2 2015-09-18. Abstract and background read | https://arxiv.org/abs/1509.05393 |
| Kleppmann 2017 | Kleppmann (2017). Designing Data-Intensive Applications. O'Reilly. Not opened; cited for what the publisher says | https://dataintensive.net/ |
| Knauf 2022 | Knauf (2022). Architecture docs as code with Structurizr and Asciidoctor, part 2: Asciidoctor. codecentric blog, 13 October 2022 | https://www.codecentric.de/wissens-hub/blog/architecture-documentation-as-code-with-structurizr-and-asciidoctor-part-2-asciidoctor |
| Knuth 1984 | Knuth (1984). Literate programming. The Computer Journal | https://doi.org/10.1093/comjnl/27.2.97 |
| Koç 2021 | Koç, Erdoğan, Barjakly, Peker (2021). UML diagrams in software engineering research: a systematic literature review. Proceedings 74(1), 13 | https://doi.org/10.3390/proceedings2021074013 |
| Kochhar 2017 | Kochhar, Lo (2017). Revisiting assert use in GitHub projects. EASE. Read in a search summary | https://doi.org/10.1145/3084226.3084259 |
| Kondo 2025 | Kondo, Alfadel, McIntosh, Ubayashi, Kamei (2025). An empirical study on declined proposals: why are these proposals declined? Preprint | arXiv:2510.06984 |
| Koning 2002 | Koning, Dormann, van Vliet (2002). Practical guidelines for the readability of IT-architecture diagrams. SIGDOC | https://doi.org/10.1145/584955.584969 |
| Kotstein 2021 | Kotstein, Bogner (2021). Which RESTful API design rules are important and how do they improve software quality? A Delphi study with industry experts. SummerSoC (arXiv 2108.00033; abstract read) | https://arxiv.org/abs/2108.00033 |
| Kourie 2012 | Kourie, Watson (2012). The correctness-by-construction approach to programming. Springer. Book not opened | https://doi.org/10.1007/978-3-642-27919-5 |
| Kreher 2026 | Kreher, Stinson (undated, read 2026). Pseudocode: a LaTeX style file for displaying algorithms. Software note | https://cs.uwaterloo.ca/~dstinson/papers/pseudocode.pdf |
| Kruchten 1995 | Kruchten (1995). The 4+1 view model of architecture. IEEE Software | https://doi.org/10.1109/52.469759 |
| Kubernetes 2026 | Kubernetes (read 2026). Kubernetes enhancements repository: KEP template (README of NNNN-kep-template) | https://github.com/kubernetes/enhancements/blob/master/keps/NNNN-kep-template/README.md |
| Kulal 2019 | Kulal, Pasupat, Chandra, Lee, Padon, Aiken, Liang (2019). SPoC: search-based pseudocode to code. NeurIPS | https://arxiv.org/abs/1906.04908 |
| Lahiri 2022 | Lahiri, Fakhoury, Naik, Sakkas, Chakraborty, Musuvathi, Choudhury, von Veh, et al. (2022). Interactive code generation via test-driven user-intent formalization. Preprint; abstract read | https://arxiv.org/abs/2208.05950 |
| Lahiri 2024 | Lahiri (2024). Evaluating LLM-driven user-intent formalization for verification-aware languages. Preprint; abstract read | https://arxiv.org/abs/2406.09757 |
| Lampson 1983 | Lampson (1983). Hints for computer system design. SOSP, 33-48. Author copy read. Open copy: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/acrobat-17.pdf | https://doi.org/10.1145/800217.806614 |
| Lampson 2020 | Lampson (2020, revised 2021-05-14). Hints and principles for computer system design. Preprint, long revision of the 1983 paper. Abstract, contents and a text scan read | https://arxiv.org/abs/2011.02455 |
| Larkin 1987 | Larkin, Simon (1987). Why a diagram is (sometimes) worth ten thousand words. Cognitive Science | https://doi.org/10.1111/j.1551-6708.1987.tb00863.x |
| Larsen 2026 | Larsen, Moghaddam (2026). RAD-AI: rethinking architecture documentation for AI-augmented ecosystems. ICSA companion, 229-236 | https://doi.org/10.1109/ICSA-C68850.2026.00054 , arXiv:2603.28735 |
| Le 2018 | Le, Link, Shahbazian, Medvidovic (2018). An empirical study of architectural decay in open-source software. ICSA. Located only: opening of the abstract read | https://doi.org/10.1109/icsa.2018.00027 |
| Lee 1997 | Lee (1997). Design rationale systems: understanding the issues. IEEE Expert | https://doi.org/10.1109/64.592267 |
| Lethbridge 2003 | Lethbridge, Singer, Forward (2003). How software engineers use documentation: the state of the practice. IEEE Software 20(6), 35-39. Full text read | https://doi.org/10.1109/MS.2003.1241364 |
| Levitin 1999 | Levitin (1999). Do we teach the right algorithm design techniques? SIGCSE. Full text read through a library | https://doi.org/10.1145/299649.299747 |
| Levitin 2000 | Levitin (2000-04). A new road map of algorithm design techniques. Dr. Dobb's Journal. Read on an archive of the magazine's articles | https://jacobfilipp.com/DrDobbs/articles/DDJ/2000/0004/0004b/0004b.htm |
| Lewis 2014 | Lewis, Fowler (2014-03-25). Microservices: a definition of this new architectural term. martinfowler.com | https://martinfowler.com/articles/microservices.html |
| Li 2013 | Li, Liang, Avgeriou (2013). Application of knowledge-based approaches in software architecture: a systematic mapping study. Information and Software Technology 55, 777-794 | https://doi.org/10.1016/j.infsof.2012.11.005 |
| Li 2013p | Li, Liang, O'Brien, Zhang (2013). The cloud's cloudy moment: a systematic survey of public cloud service outage. International Journal of Cloud Computing and Services Science 2(5) (arXiv 1312.6485; abstract read) | https://arxiv.org/abs/1312.6485 |
| Li 2022 | Li, Liang, Soliman, Avgeriou (2022). Understanding software architecture erosion: a systematic mapping study. Journal of Software: Evolution and Process. Abstract read | https://doi.org/10.1002/smr.2423 |
| Li 2023b | Li, Li, Li, Jin (2023). Structured chain-of-thought prompting for code generation. Preprint; abstract read | https://arxiv.org/abs/2305.06599 |
| Li 2024 | Li, Wu, Tang, Shi, Yang et al. (2024). Prompting large language models to tackle the full software development lifecycle: a case study (DevEval). Preprint. Abstract read | arXiv:2403.08604 |
| Li 2025 | Li, Zetzsche, Somayyajula (2025). Dafny as verification-aware intermediate language for code generation. Preprint; abstract read | https://arxiv.org/abs/2501.06283 |
| Lima Neto 2015 | Lima Neto, von Flach Garcia Chavez, de Almeida, Rost, Naab (2015). Unveiling architecture documentation: Brazilian stakeholders in perspective. Preprint | arXiv:1510.06229 |
| Liu 2019 | Liu, Lu, Musuvathi, Nath (2019). What bugs cause production cloud incidents? HotOS, 155-162. Abstract read | https://doi.org/10.1145/3317550.3321438 |
| Liu 2024b | Liu, Poulsen, Goodwin, Chen, Williams, Gertner, Franklin (2024). Teaching algorithm design: a literature review. Preprint; read in part | https://arxiv.org/abs/2405.00832 |
| Loksa 2016 | Loksa, Ko, Jernigan, Oleson, Mendez, Burnett (2016). Programming, problem solving, and self-awareness: effects of explicit guidance. CHI | https://doi.org/10.1145/2858036.2858252 |
| López-García 2025 | López-García et al. (2025). Improving university students' learning of programming using customised pseudocode. Computer Applications in Engineering Education | https://doi.org/10.1002/cae.70061 |
| Loughridge 2024 | Loughridge, Sun, Ahrenbach, Cassano, Sun, Sheng, Mudide, Misu, et al. (2024). DafnyBench: a benchmark for formal software verification. Preprint; abstract read | https://arxiv.org/abs/2406.08467 |
| Loukides 2020 | Loukides, Swoyer (2020-07-15). Microservices adoption in 2020. O'Reilly Radar | https://oreilly.com/radar/microservices-adoption-in-2020 |
| MacCormack 2006 | MacCormack, Rusnak, Baldwin (2006). Exploring the structure of complex software designs: an empirical study of open source and proprietary code. Management Science. Abstract read (Crossref) | https://doi.org/10.1287/mnsc.1060.0552 |
| MacCormack 2012 | MacCormack, Baldwin, Rusnak (2012). Exploring the duality between product and organizational architectures: a test of the mirroring hypothesis. Research Policy. Abstract partly read | https://doi.org/10.1016/j.respol.2012.04.011 |
| Machini 2024 | Machini, Casas (2024, volume 37 in 2025). Web API usability: a systematic mapping study. Interacting with Computers 37, 120-130. Abstract read on the publisher page | https://doi.org/10.1093/iwc/iwae053 |
| MacIver 2019 | MacIver, Hatfield-Dodds, contributors (2019). Hypothesis: a new approach to property-based testing. Journal of Open Source Software | https://doi.org/10.21105/joss.01891 |
| MacLean 1991 | MacLean, Young, Bellotti, Moran (1991). Questions, options, and criteria: elements of design space analysis. Human-Computer Interaction | https://doi.org/10.1207/s15327051hci0603&4_2 |
| MADR 2024 | MADR (2024). Markdown Architectural Decision Records, version 4.0.0 (2024-09-17). Project page | https://adr.github.io/madr/ |
| Malavolta 2013 | Malavolta, Lago, Muccini, Pelliccione, Tang (2013). What industry needs from architectural languages: a survey. IEEE TSE | https://doi.org/10.1109/TSE.2012.74 |
| Manai 2019 | Manai (2019). How software documentation helps communication in development teams: a case study on architecture and design documents. Student essay, University of Gothenburg. Read through a summary of its abstract | https://gupea.ub.gu.se/handle/2077/62545 |
| Mangano 2015 | Mangano, LaToza, Petre, van der Hoek (2015). How software designers interact with sketches at the whiteboard. IEEE TSE | https://doi.org/10.1109/TSE.2014.2362924 |
| Manteuffel 2014 | Manteuffel, Tofan, Koziolek, Goldschmidt, Avgeriou (2014). Industrial implementation of a documentation framework for architectural decisions. WICSA. Title and venue only | https://doi.org/10.1109/wicsa.2014.32 |
| Mathews 2024 | Mathews, Nagappan (2024). Test-driven development and LLM-based code generation. ASE. Abstract read | https://doi.org/10.1145/3691620.3695527 |
| matklad 2021 | matklad (2021). ARCHITECTURE.md. Blog post, 6 February 2021 | https://matklad.github.io/2021/02/06/ARCHITECTURE.md.html |
| Mauerer 2022 | Mauerer, Joblin, Tamburri, Paradis, Kazman, Apel (2022). In search of socio-technical congruence: a large-scale longitudinal study. IEEE TSE. Abstract read | https://doi.org/10.1109/tse.2021.3082074 , arXiv:2105.08198 |
| Mavrogiorgou 2025 | Mavrogiorgou, Kiourtis, Kyriazis, Serrano (2025). C4 model: a research guide for designing software architectures. ICoSSE | https://doi.org/10.1109/ICoSSE65712.2025.00009 |
| Mbaka 2024 | Mbaka, Tuma (2024). Usefulness of data flow diagrams and large language models for security threat validation: a registered report. arXiv preprint | https://arxiv.org/abs/2408.07537 |
| McConnell 2004 | McConnell (2004). Code Complete, 2nd edition, chapter 9: the pseudocode programming process. Microsoft Press (book not read; described by secondary sources) | https://www.oreilly.com/library/view/code-complete-2nd/0735619670/ |
| McGeoch 2012 | McGeoch (2012). A guide to experimental algorithmics. Cambridge University Press. Described by the publisher's record; book not opened | https://doi.org/10.1017/cbo9780511843747 |
| Mendonca 2021 | Mendonca, Box, Manolache, Ryan (2021). The monolith strikes back: why Istio migrated from microservices to a monolithic architecture. IEEE Software. Abstract read | https://doi.org/10.1109/ms.2021.3080335 |
| Merino 2018 | Merino, Ghafari, Anslow, Nierstrasz (2018). A systematic literature review of software visualization evaluation. Journal of Systems and Software | https://doi.org/10.1016/j.jss.2018.06.027 |
| Mermaid 2026 | Mermaid repository, GitHub (stars read 2026-10-28) | https://github.com/mermaid-js/mermaid |
| Mermaid 2026b | Mermaid project (undated, read 2026). About Mermaid, introduction page | https://mermaid.js.org/intro/ |
| Meyer 1992 | Meyer (1992). Applying design by contract. IEEE Computer. Title and venue only | https://doi.org/10.1109/2.161279 |
| Microsoft 2023 | Microsoft (2023-08-07). Visualize risk, in: Identifying infrastructure risks with threat modeling. Microsoft Learn training unit | https://learn.microsoft.com/en-us/training/modules/threat-modeling-enterprise-infrastructure/4-visualize-risk |
| Microsoft 2025 | Microsoft (page dated 2025-09-25). Architecture styles. Azure Architecture Center | https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/ |
| Microsoft 2026 icons | Microsoft (page updated 2026-10-09, read 2026-10-28). Azure icons, Azure Architecture Center | https://learn.microsoft.com/en-us/azure/architecture/icons/ |
| Microsoft 2026 ADR | Microsoft Azure Well-Architected Framework: maintain an architecture decision record (page dated 2026-04-10) | https://learn.microsoft.com/en-us/azure/well-architected/architect-role/architecture-decision-record |
| Microsoft API 2026 | Microsoft (repository read 2026-10-29). Microsoft REST API guidelines, 23.3k stars on the page | https://github.com/microsoft/api-guidelines |
| Migliorini 2024 | Migliorini, Verdecchia, Malavolta, Lago, Vicario (2024). Architectural views: the state of practice in open-source software projects. ECSA, LNCS | https://doi.org/10.1007/978-3-031-70797-1_27 |
| Misu 2024 | Misu, Lopes, Ma, Noble (2024). Towards AI-assisted synthesis of verified Dafny methods. Proceedings of the ACM on Software Engineering. Abstract read | https://doi.org/10.1145/3643763 |
| Mo 2015 | Mo, Cai, Kazman, Xiao (2015). Hotspot patterns: the formal definition and automatic detection of architecture smells. WICSA. Abstract read in a search summary (secondary) | https://doi.org/10.1109/wicsa.2015.12 |
| Mo 2016 | Mo, Cai, Kazman, Xiao, Feng (2016). Decoupling level: a new metric for architectural maintenance complexity. ICSE. Abstract read in a search summary (secondary) | https://doi.org/10.1145/2884781.2884825 |
| Mohanani 2020 | Mohanani, Salman, Turhan, Rodriguez, Ralph (2020). Cognitive biases in software engineering: a systematic mapping study. IEEE TSE. Preprint abstract read (the preprint's first version gives other counts) | https://doi.org/10.1109/tse.2018.2877759 , arXiv:1707.03869 |
| Moody 2009a | Moody (2009). The "physics" of notations: toward a scientific basis for constructing visual notations in software engineering. IEEE TSE | https://doi.org/10.1109/TSE.2009.67 |
| Moody 2009b | Moody, van Hillegersberg (2009). Evaluating the visual syntax of UML. SLE 2008 | https://doi.org/10.1007/978-3-642-00434-6_3 |
| Moody 2010 | Moody, Heymans, Matulevicius (2010). Visual syntax does matter: improving the cognitive effectiveness of the i* visual notation. Requirements Engineering | https://doi.org/10.1007/s00766-010-0100-1 |
| Müller 2002 | Müller, Typke, Hagner (2002). Two controlled experiments concerning the usefulness of assertions as a means for programming. ICSM. Read in a search summary | https://doi.org/10.1109/icsm.2002.1167755 |
| Müller 2020 | Müller (2020-09-16). Under deconstruction: the state of Shopify's monolith. Shopify Engineering | https://shopify.engineering/shopify-monolith |
| Müller-Hannemann 2010 | Müller-Hannemann, Schirra, editors (2010). Algorithm engineering: bridging the gap between algorithm theory and practice. Lecture Notes in Computer Science 5971. Title only | https://doi.org/10.1007/978-3-642-14866-8 |
| Mumtaz 2021 | Mumtaz, Singh, Blincoe (2021). A systematic mapping study on architectural smells detection. Journal of Systems and Software 173. Abstract read | https://doi.org/10.1016/j.jss.2020.110885 |
| Murphy 2017 | Murphy and colleagues (2017). Preliminary analysis of REST API style guidelines: 32 published company guidelines. Google Research page; the count and finding are from a search summary (secondary); venue PLATEAU 2017 (publisher page) | https://research.google/pubs/pub46674/ |
| Murphy 2018 | Murphy, Kery, Alliyu, Macvean and others (2018). API designers in the field: design practices and challenges for creating usable APIs. VL/HCC, 249-258 | https://doi.org/10.1109/vlhcc.2018.8506523 |
| Murr 2023 | Murr, Grainger, Gao (2023). Testing LLMs on code generation with varying levels of prompt specificity. Preprint; abstract read, results not read | https://arxiv.org/abs/2311.07599 |
| Muszynski 2022 | Muszynski, Lugtigheid, Castor, Brinkkemper (2022). A study on the software architecture documentation practices and maturity in open-source software development. ICSA | https://doi.org/10.1109/ICSA53651.2022.00013 |
| Myers 2016 | Myers, Stylos (2016). Improving API usability. Communications of the ACM 59(6), 62-69. Read in the authors' submitted version. Open copy: http://www.cs.cmu.edu/~NatProg/papers/API_Usability_Article_submitted.pdf | https://doi.org/10.1145/2896587 |
| Nagappan 2008 | Nagappan, Murphy, Basili (2008). The influence of organizational structure on software quality: an empirical case study. ICSE. Abstract read | https://doi.org/10.1145/1368088.1368160 |
| Nakagawa 2010 | Nakagawa, Feitosa, Felizardo (2010). Using systematic mapping to explore software architecture knowledge. SHARK workshop | https://doi.org/10.1145/1833335.1833340 |
| Nakashima 2026 | Nakashima, Kondo, Alfadel (2026). Toward linking declined proposals and source code: an exploratory study on the Go repository. Preprint. Abstract only | arXiv:2602.09467 |
| Nayebi 2019 | Nayebi, Cai, Kazman, Ruhe, Feng, Carlson, Chew (2019). A longitudinal study of identifying and paying down architecture debt. ICSE-SEIP. Abstract read | https://doi.org/10.1109/icse-seip.2019.00026 , arXiv:1811.12904 |
| Neatu 2026 | Neațu (2026-03-07). Are C++ contracts ready to ship in C++26? Committee paper P4043R0, WG21. Read 2026-10-29 | https://web.archive.org/web/20260320193358/https://isocpp.org/files/papers/P4043R0.html |
| Neumüller 2025 | Neumüller, Raschke, Tichy (2025). Providing information about implemented algorithms improves program comprehension: a controlled experiment. EASE | https://arxiv.org/abs/2504.19225 |
| Newcombe 2015 | Newcombe, Rath, Zhang, Munteanu, Brooker, Deardeuff (2015). How Amazon Web Services uses formal methods. Communications of the ACM (a company's report on itself) | https://doi.org/10.1145/2699417 |
| Nicacio 2022 | Nicacio, Petrillo (2022). An approach to build consistent software architecture diagrams using DevOps system descriptors. arXiv preprint (MODELS 2022 per the arXiv record) | https://arxiv.org/abs/2210.11910 |
| Nogueira 2026 | Nogueira, Silva, Conte (2026). One size fits all? An empirical comparison of ADR templates regarding comprehension, usability, and ease of adoption. Preprint, EASE 2026 | arXiv:2604.27333 |
| Noonan 2018 | Noonan (2018-07-10). Goodbye microservices: from 100s of problem children to 1 superstar. Segment blog, now at Twilio | https://www.twilio.com/en-us/blog/developers/best-practices/goodbye-microservices/ |
| Noone 2018 | Noone, Mooney (2018). Visual and textual programming languages: a systematic review of the literature. Journal of Computers in Education 5(2), 149-174 | https://doi.org/10.1007/s40692-018-0101-5 |
| npm 2026 | npm download counts for mermaid, last month to 2026-10-27 | https://api.npmjs.org/downloads/point/last-month/mermaid |
| Nuseibeh 2001 | Nuseibeh (2001). Weaving together requirements and architectures. IEEE Computer 34(3), 115-119. Read in full (the Open University's copy) | https://doi.org/10.1109/2.910904 |
| Nygard 2011 | Nygard (2011-11-15). Documenting architecture decisions. Cognitect blog | https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions |
| Obaidellah 2018 | Obaidellah, Al Haek, Cheng (2018). A survey on the usage of eye-tracking in computer programming. ACM Computing Surveys 51(1), 1-58 | https://doi.org/10.1145/3145904 |
| Obaidellah 2020 | Obaidellah, Blascheck, Guarnera, Maletic (2020). A fine-grained assessment on novice programmers' gaze patterns on pseudocode problems. ETRA | https://doi.org/10.1145/3379156.3391982 |
| OCR 2026 | OCR (2026). GCSE (9-1) Computer Science J277 specification, version 3.1 | https://www.ocr.org.uk/Images/558027-specification-gcse-computer-science-j277.pdf |
| Oda 2015 | Oda, Fudaba, Neubig, Hata, Sakti, Toda, Nakamura (2015). Learning to generate pseudo-code from source code using statistical machine translation. ASE | https://doi.org/10.1109/ASE.2015.36 |
| Okumus 2025 | Okumus, Ramic, Kugele (2025). A systematic mapping study on contract-based software design for dependable systems. Preprint; abstract read | https://arxiv.org/abs/2505.07542 |
| OMG 2017 | Object Management Group (2017). Unified Modeling Language 2.5.1 | https://www.omg.org/spec/UML/2.5.1/ |
| OMG 2024 | Object Management Group. Systems Modeling Language (SysML) v2 | https://www.omg.org/spec/SysML/2.0/ |
| Ousterhout 2021 | Ousterhout (2021). A Philosophy of Software Design, 2nd ed. Book, not opened; author's page read | https://web.stanford.edu/~ouster/cgi-bin/book.php |
| OWASP 2026 | OWASP Cheat Sheet Series team (undated, read 2026). Threat Modeling Cheat Sheet | https://cheatsheetseries.owasp.org/cheatsheets/Threat_Modeling_Cheat_Sheet.html |
| Owotogbe 2025 | Owotogbe, Kumara, van den Heuvel, Tamburri (2025). Chaos engineering: a multi-vocal literature review. ACM Computing Surveys 58 (arXiv 2412.01416, v2 2025-06-19). Abstract read: 96 sources, 2016-01 to 2024-04. Open copy: https://arxiv.org/abs/2412.01416 | https://doi.org/10.1145/3777375 |
| Ozkaya 2020 | Ozkaya, Erata (2020). A survey on the practical use of UML for different software architecture viewpoints. Information and Software Technology | https://doi.org/10.1016/j.infsof.2020.106275 |
| Parnas 1972 | Parnas (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM. Abstract read in a search summary (secondary); full text not reached | https://doi.org/10.1145/361598.361623 |
| Parnas 1987 | Parnas, Weiss (1987). Active design reviews: principles and practices. Journal of Systems and Software | https://doi.org/10.1016/0164-1212%2887%2990025-2 |
| Pearson 2018 | Pearson Edexcel (2018). International GCSE (9-1) Computer Science, components 1 and 2: pseudocode command set | https://qualifications.pearson.com/content/dam/pdf/International%20GCSE/computer-science/2017/formsandadministration/pseudocode-command-set-4cp0-02.pdf |
| Penchikala 2009 | Penchikala (2009). Virtual panel on software architecture documentation, with Bass, Booch, Merson and Woods. InfoQ, 10 August 2009 | https://www.infoq.com/articles/virtual-panel-arch-documentation/ |
| Perkins 2020 | Perkins (2020-08-13). Why write ADRs. GitHub engineering blog | https://github.blog/2020-08-13-why-write-adrs |
| Perry 1992 | Perry, Wolf (1992). Foundations for the study of software architecture. ACM SIGSOFT Software Engineering Notes | https://doi.org/10.1145/141874.141884 |
| Petre 1995 | Petre (1995). Why looking isn't always seeing: readership skills and graphical programming. Communications of the ACM | https://doi.org/10.1145/203241.203251 |
| Petre 2013 | Petre (2013). UML in practice. ICSE | https://doi.org/10.1109/ICSE.2013.6606618 |
| Pfleeger 1997 | Pfleeger, Hatton (1997). Investigating the influence of formal methods. IEEE Computer 30(2), 33-43. A preprint copy circulated under the title Do formal methods improve code quality was read on an author's site | https://doi.org/10.1109/2.566148 |
| Piccioni 2013 | Piccioni, Furia, Meyer (2013). An empirical study of API usability. ESEM, 5-14. Author copy read: 25 programmers, one persistence library. Open copy: https://se.inf.ethz.ch/~meyer/publications/empirical/API_usability.pdf | https://doi.org/10.1109/esem.2013.14 |
| Pimentel 2021 | Pimentel, Murta, Braganholo, Freire (2021). Understanding and improving the quality and reproducibility of Jupyter notebooks. Empirical Software Engineering | https://doi.org/10.1007/s10664-021-09961-9 |
| Piskala 2026 | Piskala (2026). Spec-driven development: from code to contract in the age of AI coding assistants. Preprint, 2026-01; abstract read | https://arxiv.org/abs/2602.00180 |
| PlantUML 2026 | PlantUML repository, GitHub (stars read 2026-10-28) | https://github.com/plantuml/plantuml |
| Polikarpova 2013 | Polikarpova, Furia, Pei, Wei, Meyer (2013). What good are strong specifications? ICSE. Abstract read | https://doi.org/10.1109/icse.2013.6606572 |
| Polishchuk 2026 | Polishchuk (2026-06-21). 10 ADR anti-patterns architects should stop repeating. Blog post | https://jopr.org/blog/detail/10-adr-antipatterns |
| Polya 1945 | Polya (1945). How to solve it. Princeton University Press (the DOI is that of the reissue; book not opened) | https://doi.org/10.1515/9781400828678 |
| Pragmatic Engineer 2022 | Orosz (2022, updated 2024). Companies using RFCs or design docs, and examples | https://blog.pragmaticengineer.com/rfcs-and-design-docs/ |
| Prechelt 2001 | Prechelt, Unger, Tichy, Brossler et al. (2001). A controlled experiment in maintenance: comparing design patterns to simpler solutions. IEEE TSE. Abstract read on the research group's page | https://doi.org/10.1109/32.988711 |
| Prechelt 2002 | Prechelt, Unger-Lamprecht, Philippsen, Tichy (2002). Two controlled experiments assessing the usefulness of design pattern documentation in program maintenance. IEEE TSE 28(6). Numbers from the earlier draft abstract (secondary) | https://doi.org/10.1109/TSE.2002.1010061 |
| Pretorius 2008 | Pretorius, Budgen (2008). A mapping study on empirical evidence related to the models and forms used in the UML. ESEM | https://doi.org/10.1145/1414004.1414076 |
| Primer 2026 | donnemartin, repository owner (repository created 2017-02-26, last push 2026-09-15; read 2026-10-29). The system design primer: 375,957 stars on 2026-10-29 | https://github.com/donnemartin/system-design-primer |
| Purchase 2002 | Purchase, Allder, Carrington (2002). Graph layout aesthetics in UML diagrams: user preferences. Journal of Graph Algorithms and Applications | https://doi.org/10.7155/jgaa.00054 |
| Rabkin 2013 | Rabkin, Katz (2013). How Hadoop clusters break. IEEE Software. Named in the related work of Yuan 2014; title and venue only | https://doi.org/10.1109/ms.2012.73 |
| Rafique 2013 | Rafique, Mišić (2013). The effects of test-driven development on external quality and productivity: a meta-analysis. IEEE Transactions on Software Engineering 39(6), 836-856. Read in search summaries only | https://doi.org/10.1109/tse.2012.28 |
| Rahmanian 2026 | Rahmanian, Sami, Yu (2026). Large language models for software engineering diagrams: a systematic review of UML and ER modelling. arXiv preprint | https://arxiv.org/abs/2607.26100 |
| Ramsey 1983 | Ramsey, Atwood, Van Doren (1983). Flowcharts versus program design languages. Communications of the ACM | https://doi.org/10.1145/358141.358149 |
| Rauf 2019 | Rauf, Troubitsyna, Porres (2019). A systematic mapping study of API usability evaluation methods. Computer Science Review 33, 49-68 | https://doi.org/10.1016/j.cosrev.2019.05.001 |
| Razavian 2016 | Razavian, Tang, Capilla, Lago (2016). In two minds: how reflections influence software design thinking. Journal of Software: Evolution and Process. Abstract read through a library | https://doi.org/10.1002/smr.1776 |
| Razavian 2019 | Razavian, Paech, Tang (2019). Empirical research for software architecture decision making: an analysis. Journal of Systems and Software 149, 360-381. Abstract only, partly | https://doi.org/10.1016/j.jss.2018.12.003 |
| Regli 2000 | Regli, Hu, Atwood, Sun (2000). A survey of design rationale systems: approaches, representation, capture and retrieval. Engineering with Computers | https://doi.org/10.1007/pl00013715 |
| Rheault 2023 | Rheault, Dougherty, Blanchard (2023). Pseudocode vs. compile-and-run prompts: comparing measures of student programming ability in CS1 and CS2. ITiCSE | https://doi.org/10.1145/3587102.3588834 |
| Ribeiro 2026 | Ribeiro, Alves (2026). Onboarding in software engineering: a multivocal literature review. Information and Software Technology 196, 108120 | https://doi.org/10.1016/j.infsof.2026.108120 |
| Robillard 2016 | Robillard, Medvidovic (2016). Disseminating architectural knowledge on open-source projects: a case study of the book Architecture of Open-Source Applications. ICSE | https://doi.org/10.1145/2884781.2884792 |
| Robins 2003 | Robins, Rountree, Rountree (2003). Learning and teaching programming: a review and discussion. Computer Science Education 13(2). Read in a search summary only | https://doi.org/10.1076/csed.13.2.137.14200 |
| Rosetta Code 2026 | Rosetta Code (read 2026). Rosetta Code: a programming chrestomathy site | https://rosettacode.org/wiki/Rosetta_Code |
| Rost 2013 | Rost, Naab, Lima, von Flach Garcia Chavez (2013). Software architecture documentation for developers: a survey. ECSA, LNCS. Numbers read in the full survey report of the same study | https://doi.org/10.1007/978-3-642-39031-9_7 , https://www.iese.fraunhofer.de/content/dam/iese/dokumente/alte-dateien/study_software_architecture_documentation_for_developers_survey-en-fraunhofer_iese.pdf |
| Rost 2016 | Rost, Naab (2016). Task-specific architecture documentation for developers: why separation of concerns in architecture documentation is counterproductive for developers. ECSA workshops, LNCS, 102-110 | https://doi.org/10.1007/978-3-319-48992-6_7 |
| Rozanski 2011 | Rozanski, Woods (2011). Software Systems Architecture: Working with Stakeholders Using Viewpoints and Perspectives, 2nd ed. Addison-Wesley. Catalogue and definitions read on the book's site | https://www.viewpoints-and-perspectives.info/home/viewpoints/ |
| Rukmono 2026 | Rukmono, Zamfirov, Ochoa, Pex, Chaudron (2026). An explanation of software architecture explanations. Empirical Software Engineering | https://doi.org/10.1007/s10664-025-10782-3 , arXiv:2503.08628 |
| Rule 2018 | Rule, Tabard, Hollan (2018). Exploration and explanation in computational notebooks. CHI | https://doi.org/10.1145/3173574.3173606 |
| Runde 2018 | Runde, Keeling (2018). Share the load: distributing design authority with lightweight decision records. Agile2018 session page on the Agile Alliance site | https://www.agilealliance.org/?p=8043624 |
| Rust 2026a | Rust project (read 2026). Rust RFCs repository: README, the RFC process | https://github.com/rust-lang/rfcs/blob/master/README.md |
| Rust 2026b | Rust project (read 2026). Rust RFCs repository: 0000-template.md | https://github.com/rust-lang/rfcs/blob/master/0000-template.md |
| Rust 2026c | rust-analyzer project (undated, read 2026). Architecture. Project documentation | https://github.com/rust-lang/rust-analyzer/blob/master/docs/book/src/contributing/architecture.md |
| Sahu 2026 | Sahu, Bothra, Arun, Godfrey, Narayan, Saeed (2026). Assistants, not architects: the role of LLMs in networked systems design. Preprint, 2026-04-28; abstract only | https://arxiv.org/abs/2604.25506 |
| Saltzer 1984 | Saltzer, Reed, Clark (1984). End-to-end arguments in system design. ACM Transactions on Computer Systems 2(4), 277-288. Author copy: abstract, introduction and argument read. Open copy: https://web.mit.edu/Saltzer/www/publications/endtoend/endtoend.pdf | https://doi.org/10.1145/357401.357402 |
| Saltzer 2009 | Saltzer, Kaashoek (2009). Principles of computer system design: an introduction. Morgan Kaufmann. Not opened; one chapter DOI | https://doi.org/10.1016/b978-0-12-374957-4.00010-4 |
| Sanders 2009 | Sanders (2009). Algorithm engineering, an attempt at a definition. Lecture Notes in Computer Science. Full text read | https://doi.org/10.1007/978-3-642-03456-5_22 |
| Santana 2026 | de Santana Junior, Figueiredo, Peixoto, Araujo, Prazeres, Machado, Silveira Neto, Almeida (2026). Architecture decision records: adoption, impact, and developer engagement in open-source software. ICSA 2026 (conference page, abstract only) | https://conf.researchr.org/details/icsa-2026/icsa-2026-papers/34/Architecture-Decision-Records-Adoption-Impact-and-Developer-Engagement-in-Open-Sou |
| Santos 2018 | Santos, Gralha, Goulão, Araújo, Moreira (2018). On the impact of semantic transparency on understanding and reviewing social goal models. RE. Numbers read in the arXiv text of the same title, arXiv:2511.06110 | https://doi.org/10.1109/RE.2018.00031 |
| Santos 2025 | Santos, Felizardo, Steinmacher, Gerosa (2025). Software solutions for newcomers' onboarding in software projects: a systematic literature review. Information and Software Technology 177, 107568 | https://doi.org/10.1016/j.infsof.2024.107568 |
| Scanlan 1988 | Scanlan (1988). Should short, relatively complex algorithms be taught using both graphical and verbal methods? Six replications. SIGCSE Bulletin | https://doi.org/10.1145/52964.53011 |
| Scanlan 1989 | Scanlan (1989). Structured flowcharts outperform pseudocode: an experimental comparison. IEEE Software | https://doi.org/10.1109/52.35587 |
| Scanniello 2018 | Scanniello, Gravino, Genero, Cruz-Lemus, Tortora, Risi, Dodero (2018). Do software models based on the UML aid in source-code comprehensibility? Aggregating evidence from 12 controlled experiments. Empirical Software Engineering | https://doi.org/10.1007/s10664-017-9591-4 |
| Schmid 2025 | Schmid, Hey, Armbruster, Corallo, Fuchss, Keim et al. (2025). Software architecture meets LLMs: a systematic literature review. Preprint. Abstract read | arXiv:2505.16697 |
| Schneider 2024 | Schneider et al. (2024). How dataflow diagrams impact software security analysis: an empirical experiment. SANER | https://doi.org/10.1109/SANER60148.2024.00103 |
| Schoonewille 2011 | Schoonewille, Heijstek, Chaudron, Kühne (2011). A cognitive perspective on developer comprehension of software design documentation. SIGDOC, 211-218. Result read in a secondary summary | https://doi.org/10.1145/2038476.2038517 |
| Sedgewick 2026 | Sedgewick, Wayne (undated, read 2026). Algorithms, 4th edition: booksite | https://algs4.cs.princeton.edu/home/ |
| SESE 2010a | "Is an architecture description document a violation of the DRY Principle?". Software Engineering Stack Exchange, question 10757, asked 2010-10; read 2026-10-28 (11 votes, 875 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/10757 |
| SESE 2010b | "What do you put into an Architecture Specification?". Software Engineering Stack Exchange, question 26188, asked 2010-12; read 2026-10-28 (4 votes, 936 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/26188 |
| SESE 2010c | "What does your Technical Documentation look like?". Software Engineering Stack Exchange, question 29488, asked 2010-12; read 2026-10-28 (18 votes, 14737 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/29488 |
| SESE 2010d | "How much time do you devote to the design document(s) for your software?". Software Engineering Stack Exchange, question 8564, asked 2010-09; read 2026-10-28 (6 votes, 5436 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/8564 |
| SESE 2010e | "Should one use pseudocode before actual coding?". Software Engineering Stack Exchange, question 12683, asked 2010-10; read 2026-10-28 (21 votes, 28259 views, 16 answers). | https://softwareengineering.stackexchange.com/questions/12683 |
| SESE 2010f | "Are Nassi-Shneiderman diagrams actually used?". Software Engineering Stack Exchange, question 3884, asked 2010-09; read 2026-10-28 (8 votes, 5193 views, 8 answers). | https://softwareengineering.stackexchange.com/questions/3884 |
| SESE 2010g | "How often do you use Formal UML?". Software Engineering Stack Exchange, question 1095, asked 2010-09; read 2026-10-28 (35 votes, 3249 views, 13 answers). | https://softwareengineering.stackexchange.com/questions/1095 |
| SESE 2010h | "If you learned formal methods for software, how useful have you found it?". Software Engineering Stack Exchange, question 10358, asked 2010-10; read 2026-10-29 (20 votes, 3664 views, 8 answers). | https://softwareengineering.stackexchange.com/questions/10358 |
| SESE 2011a | "How can open source projects be successful without documentation about their design or architecture?". Software Engineering Stack Exchange, question 87994, asked 2011-06; read 2026-10-28 (12 votes, 4224 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/87994 |
| SESE 2011b | "A software architecture document should present the technology used?". Software Engineering Stack Exchange, question 68503, asked 2011-04; read 2026-10-28 (0 votes, 1923 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/68503 |
| SESE 2011c | "Should a design document contain a discussion of the pros/cons to a given design or should it focus on facts and rationale?". Software Engineering Stack Exchange, question 106693, asked 2011-09; read 2026-10-28 (13 votes, 3114 views, 7 answers). | https://softwareengineering.stackexchange.com/questions/106693 |
| SESE 2011d | "Difference between a pseudo code and algorithm?". Software Engineering Stack Exchange, question 77757, asked 2011-05; read 2026-10-28 (22 votes, 104151 views, 13 answers). | https://softwareengineering.stackexchange.com/questions/77757 |
| SESE 2011e | "Is there a standard pseudocode for parallel algorithms?". Software Engineering Stack Exchange, question 102588, asked 2011-08; read 2026-10-28 (5 votes, 2339 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/102588 |
| SESE 2011f | "In pseudo code what does := mean?". Software Engineering Stack Exchange, question 101716, asked 2011-08; read 2026-10-28 (27 votes, 34752 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/101716 |
| SESE 2011g | "Making an attractive, yet still technical architecture diagram". Software Engineering Stack Exchange, question 110333, asked 2011-09; read 2026-10-28 (13 votes, 52913 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/110333 |
| SESE 2011h | "How useful is UML if you are a developer working alone in a project". Software Engineering Stack Exchange, question 65037, asked 2011-04; read 2026-10-28 (16 votes, 1628 views, 10 answers). | https://softwareengineering.stackexchange.com/questions/65037 |
| SESE 2011i | "Is code commonly generated from UML?". Software Engineering Stack Exchange, question 124996, asked 2011-12; read 2026-10-28 (39 votes, 15325 views, 11 answers). | https://softwareengineering.stackexchange.com/questions/124996 |
| SESE 2011j | "Do you create a design with UML before you start?". Software Engineering Stack Exchange, question 81674, asked 2011-06; read 2026-10-28 (16 votes, 6085 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/81674 |
| SESE 2011k | "Is information hiding more than a convention?". Software Engineering Stack Exchange, question 98867, asked 2011-08; read 2026-10-29 (20 votes, 2,823 views, 11 answers) | https://softwareengineering.stackexchange.com/questions/98867 |
| SESE 2011l | "Should I plan ahead, or figure out programs as I'm writing them?". Software Engineering Stack Exchange, question 97985, asked 2011-08; read 2026-10-29 (56 votes, 17845 views, 15 answers). | https://softwareengineering.stackexchange.com/questions/97985 |
| SESE 2011m | "Can you write an unambiguous specification in a natural language like English?". Software Engineering Stack Exchange, question 106760, asked 2011-09; read 2026-10-29 (9 votes, 1811 views, 13 answers). | https://softwareengineering.stackexchange.com/questions/106760 |
| SESE 2011n | "Why bother with detailed specs?". Software Engineering Stack Exchange, question 61227, asked 2011-03; read 2026-10-29 (8 votes, 1712 views, 9 answers). | https://softwareengineering.stackexchange.com/questions/61227 |
| SESE 2011p | "How do I design an arbitrary system in an interview?". Software Engineering Stack Exchange, question 75269, asked 2011-05; read 2026-10-29 (36 votes, 27,414 views, 11 answers) | https://softwareengineering.stackexchange.com/questions/75269 |
| SESE 2011q | "Differences between Design by Contract and Defensive Programming". Software Engineering Stack Exchange, question 125399, asked 2011-12; read 2026-10-29 (27 votes, 11758 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/125399 |
| SESE 2012a | "What kinds of visual content, tables or diagrams might I want to include in my Project Architecture Document?". Software Engineering Stack Exchange, question 161549, asked 2012-08; read 2026-10-28 (2 votes, 478 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/161549 |
| SESE 2012b | "How-to convince company to start documenting for legacy software". Software Engineering Stack Exchange, question 132977, asked 2012-02; read 2026-10-28 (22 votes, 2253 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/132977 |
| SESE 2012c | "What is the difference between technical specifications and design documents?". Software Engineering Stack Exchange, question 179554, asked 2012-12; read 2026-10-28 (42 votes, 184827 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/179554 |
| SESE 2012d | "Documentation degrading - how to deal with it?". Software Engineering Stack Exchange, question 157870, asked 2012-07; read 2026-10-28 (13 votes, 1795 views, 7 answers). | https://softwareengineering.stackexchange.com/questions/157870 |
| SESE 2012e | "What is pseudocode?". Software Engineering Stack Exchange, question 136292, asked 2012-02; read 2026-10-28 (19 votes, 15326 views, 8 answers). | https://softwareengineering.stackexchange.com/questions/136292 |
| SESE 2012f | "When would I use pseudocode instead of flowchart?". Software Engineering Stack Exchange, question 154703, asked 2012-06; read 2026-10-28 (11 votes, 30466 views, 9 answers). | https://softwareengineering.stackexchange.com/questions/154703 |
| SESE 2012g | "Annotate source code with diagrams as comments". Software Engineering Stack Exchange, question 176316, asked 2012-11; read 2026-10-28 (18 votes, 8515 views, 6 answers). | https://softwareengineering.stackexchange.com/questions/176316 |
| SESE 2012h | ""UML is the worst thing to ever happen to MDD." Why?". Software Engineering Stack Exchange, question 153656, asked 2012-06; read 2026-10-28 (17 votes, 5244 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/153656 |
| SESE 2012i | "How important are UML diagrams for a successful project?". Software Engineering Stack Exchange, question 144530, asked 2012-04; read 2026-10-28 (22 votes, 22509 views, 20 answers). | https://softwareengineering.stackexchange.com/questions/144530 |
| SESE 2012j | "Truly useful UML diagrams". Software Engineering Stack Exchange, question 152997, asked 2012-06; read 2026-10-28 (10 votes, 8380 views, 6 answers). | https://softwareengineering.stackexchange.com/questions/152997 |
| SESE 2012k | "Are there metrics for cohesion and coupling?". Software Engineering Stack Exchange, question 151004, asked 2012-05; read 2026-10-29 (36 votes, 18,565 views, 2 answers) | https://softwareengineering.stackexchange.com/questions/151004 |
| SESE 2012l | "Why is there such limited support for Design by Contract in most modern programming languages?". Software Engineering Stack Exchange, question 128717, asked 2012-01; read 2026-10-29 (41 votes, 6249 views, 9 answers). | https://softwareengineering.stackexchange.com/questions/128717 |
| SESE 2013a | "Are the technologies used in an application part of the architecture, or do they represent implementation/detailed design details?". Software Engineering Stack Exchange, question 203399, asked 2013-07; read 2026-10-28 (5 votes, 635 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/203399 |
| SESE 2013b | "where do you track team Decisions". Software Engineering Stack Exchange, question 215373, asked 2013-10; read 2026-10-28 (7 votes, 487 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/215373 |
| SESE 2013c | "What UML diagram should I use to show a platform's architecture?". Software Engineering Stack Exchange, question 198178, asked 2013-05; read 2026-10-28 (10 votes, 13319 views, 1 answers). | https://softwareengineering.stackexchange.com/questions/198178 |
| SESE 2013d | "How are design-by-contract and property-based testing (QuickCheck) related?". Software Engineering Stack Exchange, question 203120, asked 2013-06; read 2026-10-29 (6 votes, 1121 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/203120 |
| SESE 2013p | "why are noSQL databases more scalable than SQL?". Software Engineering Stack Exchange, question 194340, asked 2013-04; read 2026-10-29 (163 votes, 115,990 views, 4 answers) | https://softwareengineering.stackexchange.com/questions/194340 |
| SESE 2013q | "Should we design programs to randomly kill themselves?". Software Engineering Stack Exchange, question 202383, asked 2013-06; read 2026-10-29 (78 votes, 5,609 views, 16 answers) | https://softwareengineering.stackexchange.com/questions/202383 |
| SESE 2014a | "Mapping between 4+1 architectural view model & UML". Software Engineering Stack Exchange, question 233257, asked 2014-03; read 2026-10-28 (25 votes, 42890 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/233257 |
| SESE 2014b | "How to document the high-level structure of a Java program?". Software Engineering Stack Exchange, question 233099, asked 2014-03; read 2026-10-28 (21 votes, 11601 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/233099 |
| SESE 2014c | "Is it acceptable to ask management for pseudo code?". Software Engineering Stack Exchange, question 257791, asked 2014-10; read 2026-10-28 (2 votes, 702 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/257791 |
| SESE 2014d | "How do I stop designing and start architecting this project as suggested by my lead?". Software Engineering Stack Exchange, question 232030, asked 2014-03; read 2026-10-29 (41 votes, 5,218 views, 7 answers) | https://softwareengineering.stackexchange.com/questions/232030 |
| SESE 2014p | "Why PATCH method is not idempotent?". Software Engineering Stack Exchange, question 260818, asked 2014-10; read 2026-10-29 (75 votes, 31,436 views, 4 answers) | https://softwareengineering.stackexchange.com/questions/260818 |
| SESE 2015a | "Where to describe architectural problems?". Software Engineering Stack Exchange, question 303010, asked 2015-11; read 2026-10-28 (18 votes, 2033 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/303010 |
| SESE 2015b | "Who should write the Technical Design Document? The BA or the Developer?". Software Engineering Stack Exchange, question 277437, asked 2015-03; read 2026-10-28 (2 votes, 19345 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/277437 |
| SESE 2015c | "Should I use future or present tense when writing a design spec document?". Software Engineering Stack Exchange, question 301754, asked 2015-11; read 2026-10-28 (9 votes, 14622 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/301754 |
| SESE 2015d | "Why is it inappropriate to use UML diagrams to plan how your code will be organized?". Software Engineering Stack Exchange, question 305093, asked 2015-12; read 2026-10-28 (11 votes, 4165 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/305093 |
| SESE 2015e | "Why is UML not used in most free software (e.g. on Linux)?". Software Engineering Stack Exchange, question 305031, asked 2015-12; read 2026-10-28 (31 votes, 5659 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/305031 |
| SESE 2015f | "What are functional programmers using in place of UML?". Software Engineering Stack Exchange, question 302811, asked 2015-11; read 2026-10-28 (31 votes, 14414 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/302811 |
| SESE 2015g | "Property based testing without reimplementing the code under test". Software Engineering Stack Exchange, question 278328, asked 2015-04; read 2026-10-29 (8 votes, 1042 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/278328 |
| SESE 2015p | "Many small requests vs. few large requests (API Design)". Software Engineering Stack Exchange, question 274340, asked 2015-02; read 2026-10-29 (76 votes, 92,648 views, 6 answers) | https://softwareengineering.stackexchange.com/questions/274340 |
| SESE 2016a | "What is an effective way to record rationales behind product design decisions?". Software Engineering Stack Exchange, question 310705, asked 2016-02; read 2026-10-28 (31 votes, 2743 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/310705 |
| SESE 2016b | "Is it normal/acceptable to write down notes, thoughts, algorithms, decisions during coding and maintenance?". Software Engineering Stack Exchange, question 329463, asked 2016-08; read 2026-10-28 (22 votes, 3299 views, 9 answers). | https://softwareengineering.stackexchange.com/questions/329463 |
| SESE 2016c | "Why do textbooks use pseudocode rather than real languages?". Software Engineering Stack Exchange, question 310695, asked 2016-02; read 2026-10-28 (7 votes, 2291 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/310695 |
| SESE 2016p | "How to design a high-availability application". Software Engineering Stack Exchange, question 338680, asked 2016-12; read 2026-10-29 (15 votes, 15,596 views, 3 answers) | https://softwareengineering.stackexchange.com/questions/338680 |
| SESE 2017a | "Is there a standard for documenting a program's high-level architecture?". Software Engineering Stack Exchange, question 347773, asked 2017-04; read 2026-10-28 (12 votes, 4610 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/347773 |
| SESE 2017b | "How to describe the architecture of a software product?". Software Engineering Stack Exchange, question 339864, asked 2017-01; read 2026-10-28 (6 votes, 10795 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/339864 |
| SESE 2017c | "Did the need for software design specification significantly decrease with the evolution of more expressive programming languages?". Software Engineering Stack Exchange, question 348575, asked 2017-05; read 2026-10-28 (17 votes, 1136 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/348575 |
| SESE 2017d | "What are the benefits of modeling software systems vs. doing it all in code?". Software Engineering Stack Exchange, question 355733, asked 2017-08; read 2026-10-28 (21 votes, 3550 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/355733 |
| SESE 2017e | "Keeping Logical and Physical Architecture diagrams updated". Software Engineering Stack Exchange, question 340311, asked 2017-01; read 2026-10-28 (11 votes, 770 views, 1 answers). | https://softwareengineering.stackexchange.com/questions/340311 |
| SESE 2017f | "Software architecture vs System architecture vs Class diagrams?". Software Engineering Stack Exchange, question 343643, asked 2017-03; read 2026-10-28 (12 votes, 13286 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/343643 |
| SESE 2017g | "Which UML diagrams are still being widely used?". Software Engineering Stack Exchange, question 339262, asked 2017-01; read 2026-10-28 (21 votes, 13646 views, 4 answers). | https://softwareengineering.stackexchange.com/questions/339262 |
| SESE 2017h | "How does shifting to microservices create a run-time problem?". Software Engineering Stack Exchange, question 339230, asked 2017-01; read 2026-10-29 (108 votes, 12,721 views, 5 answers) | https://softwareengineering.stackexchange.com/questions/339230 |
| SESE 2017p | "Microservices: Handling eventual consistency". Software Engineering Stack Exchange, question 354911, asked 2017-08; read 2026-10-29 (30 votes, 19,805 views, 6 answers) | https://softwareengineering.stackexchange.com/questions/354911 |
| SESE 2018a | "Can creating a Software Design Document after development be justified?". Software Engineering Stack Exchange, question 372041, asked 2018-06; read 2026-10-28 (11 votes, 5877 views, 6 answers). | https://softwareengineering.stackexchange.com/questions/372041 |
| SESE 2018b | "Documenting design decisions in code comments?". Software Engineering Stack Exchange, question 369158, asked 2018-04; read 2026-10-28 (6 votes, 2120 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/369158 |
| SESE 2018c | "Communicating the intended operation of API business logic to both developers and business people". Software Engineering Stack Exchange, question 372972, asked 2018-06; read 2026-10-28 (2 votes, 369 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/372972 |
| SESE 2018d | "When developing a system by myself, should I use microservices?". Software Engineering Stack Exchange, question 379499, asked 2018-10; read 2026-10-29 (31 votes, 4,675 views, 1 answers) | https://softwareengineering.stackexchange.com/questions/379499 |
| SESE 2018e | "What are the barriers that prevent widespread adoption of formal methods?". Software Engineering Stack Exchange, question 375342, asked 2018-07; read 2026-10-29 (18 votes, 3010 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/375342 |
| SESE 2018p | "How to estimate the number of machines for system design interview questions". Software Engineering Stack Exchange, question 384732, asked 2018-12; read 2026-10-29 (2 votes, 5,477 views, 1 answer) | https://softwareengineering.stackexchange.com/questions/384732 |
| SESE 2019a | "Documenting a distributed application". Software Engineering Stack Exchange, question 390438, asked 2019-04; read 2026-10-28 (0 votes, 567 views, 1 answers). | https://softwareengineering.stackexchange.com/questions/390438 |
| SESE 2019b | "How should I make it less scary for a team to create diagrams?". Software Engineering Stack Exchange, question 402672, asked 2019-12; read 2026-10-28 (9 votes, 495 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/402672 |
| SESE 2020a | "Best practices for maintainable Graphviz / PlantUML code". Software Engineering Stack Exchange, question 419927, asked 2020-12; read 2026-10-28 (2 votes, 2792 views, 3 answers). | https://softwareengineering.stackexchange.com/questions/419927 |
| SESE 2020b | "Should microservices be independent?". Software Engineering Stack Exchange, question 411082, asked 2020-06; read 2026-10-29 (33 votes, 8,333 views, 2 answers) | https://softwareengineering.stackexchange.com/questions/411082 |
| SESE 2020c | "What is the term for an architecture between a monolith and micro services". Software Engineering Stack Exchange, question 412213, asked 2020-06; read 2026-10-29 (2 votes, 373 views, 1 answers) | https://softwareengineering.stackexchange.com/questions/412213 |
| SESE 2020d | "Coupling: theory vs reality". Software Engineering Stack Exchange, question 405308, asked 2020-02; read 2026-10-29 (28 votes, 7,318 views, 9 answers) | https://softwareengineering.stackexchange.com/questions/405308 |
| SESE 2022a | "Is documenting a big project with UML Diagrams needed, good to have or even not possible?". Software Engineering Stack Exchange, question 441543, asked 2022-10; read 2026-10-28 (28 votes, 11080 views, 6 answers). | https://softwareengineering.stackexchange.com/questions/441543 |
| SESE 2022b | "I can't really tell the difference between Hexagonal and Layered Architecture". Software Engineering Stack Exchange, question 436194, asked 2022-01; read 2026-10-29 (36 votes, 21,504 views, 5 answers) | https://softwareengineering.stackexchange.com/questions/436194 |
| SESE 2022p | "How to think about system design questions methodically?". Software Engineering Stack Exchange, question 441901, asked 2022-10; read 2026-10-29 (4 votes, 693 views, 3 answers on the audit's recount) | https://softwareengineering.stackexchange.com/questions/441901 |
| SESE 2023a | "Do software engineers use UML diagrams of object models, domain models, system sequence diagrams and operation contracts?". Software Engineering Stack Exchange, question 444471, asked 2023-03; read 2026-10-28 (9 votes, 2914 views, 5 answers). | https://softwareengineering.stackexchange.com/questions/444471 |
| SESE 2024a | "Are there still advantages of the data-flow diagram in a world of SysML and UML?". Software Engineering Stack Exchange, question 456018, asked 2024-12; read 2026-10-28 (1 votes, 950 views, 2 answers). | https://softwareengineering.stackexchange.com/questions/456018 |
| SESE 2025a | "Managing growth in microservice architecture: is modular monolith the solution?". Software Engineering Stack Exchange, question 458856, asked 2025-07; read 2026-10-29 (4 votes, 685 views, 2 answers) | https://softwareengineering.stackexchange.com/questions/458856 |
| Shaft 2006 | Shaft, Vessey (2006). The role of cognitive fit in the relationship between software comprehension and modification. MIS Quarterly (title only; not read) | https://doi.org/10.2307/25148716 |
| Shahin 2009 | Shahin, Liang, Khayyambashi (2009). Architectural design decision: existing models and tools. WICSA/ECSA | https://doi.org/10.1109/wicsa.2009.5290823 |
| Shahin 2014 | Shahin, Liang, Babar (2014). A systematic review of software architecture visualization techniques. Journal of Systems and Software 94, 161-185 | https://doi.org/10.1016/j.jss.2014.03.071 |
| Sharif 2009a | Sharif, Maletic (2009). The effect of layout on the comprehension of UML class diagrams: a controlled experiment. VISSOFT | https://doi.org/10.1109/VISSOF.2009.5336430 |
| Sharif 2009b | Sharif, Maletic (2009). An empirical study on the comprehension of stereotyped UML class diagram layouts. ICPC | https://doi.org/10.1109/ICPC.2009.5090055 |
| Sharif 2010 | Sharif, Maletic (2010). An eye tracking study on the effects of layout in understanding the role of design patterns. ICSM | https://doi.org/10.1109/ICSM.2010.5609582 |
| Sharma 2022 | Nand Sharma, Savarimuthu, Stanger (2022). Unearthing open source decision-making processes: a case study of Python enhancement proposals. Software: Practice and Experience | https://doi.org/10.1002/spe.3128 |
| Shaw 1996 | Shaw, Garlan (1996). Software Architecture: perspectives on an emerging discipline. Prentice Hall. Book, not opened; library record and table of contents read | https://search.ub.tum.de/vufind/Record/DE-604.BV010778817 |
| Shneiderman 1977 | Shneiderman, Mayer, McKay, Heller (1977). Experimental investigations of the utility of detailed flowcharts in programming. Communications of the ACM | https://doi.org/10.1145/359605.359610 |
| Shum 1994 | Shum, Cook (1994). Using literate programming to teach good programming practices. SIGCSE | https://doi.org/10.1145/191029.191059 |
| Sion 2018 | Sion et al. (2018). Solution-aware data flow diagrams for security threat modeling. SAC | https://doi.org/10.1145/3167132.3167285 |
| Skelton 2025 | Skelton, Pais (2025). Team Topologies, 2nd ed. IT Revolution Press (first edition 2019). Book, not opened; publisher page read | https://teamtopologies.com/book |
| Skiena 2020 | Skiena (2020). The algorithm design manual, 3rd edition. Springer. Described by the publisher's page; book not opened | https://doi.org/10.1007/978-3-030-54256-6 |
| Snook 2001 | Snook, Harrison (2001). Practitioners' views on the use of formal methods: an industrial survey by structured interview. Information and Software Technology. Full text read | https://doi.org/10.1016/s0950-5849(00)00166-x |
| SO 2008a | "Documentation of software design and architecture". Stack Overflow, question 323823, asked 2008-11; read 2026-10-28 (2 votes, 1583 views, 1 answers). | https://stackoverflow.com/questions/323823 |
| SO 2008b | "How often do you use pseudocode in the real world?". Stack Overflow, question 360454, asked 2008-12; read 2026-10-28 (9 votes, 6401 views, 14 answers). | https://stackoverflow.com/questions/360454 |
| SO 2008c | "Pseudocode Programming Process vs. Test Driven Development". Stack Overflow, question 169020, asked 2008-10; read 2026-10-28 (16 votes, 3322 views, 6 answers). | https://stackoverflow.com/questions/169020 |
| SO 2008d | "Design By Contract and Test-Driven Development". Stack Overflow, question 394591, asked 2008-12; read 2026-10-29 (28 votes, 5147 views, 8 answers). | https://stackoverflow.com/questions/394591 |
| SO 2009a | "How specific to get on design document?". Stack Overflow, question 698415, asked 2009-03; read 2026-10-28 (7 votes, 2524 views, 7 answers). | https://stackoverflow.com/questions/698415 |
| SO 2009b | "Tools and standards for technical design document". Stack Overflow, question 1019222, asked 2009-06; read 2026-10-28 (7 votes, 2274 views, 4 answers). | https://stackoverflow.com/questions/1019222 |
| SO 2009c | "What programming language best bridges the gap between pseudocode and code?". Stack Overflow, question 953708, asked 2009-06; read 2026-10-28 (11 votes, 6199 views, 13 answers). | https://stackoverflow.com/questions/953708 |
| SO 2009d | "What is the difference between a data flow diagram and a flow chart?". Stack Overflow, question 703948, asked 2009-04; read 2026-10-28 (16 votes, 136074 views, 14 answers). | https://stackoverflow.com/questions/703948 |
| SO 2009e | "Why is design-by-contract not so popular compared to test-driven development?". Stack Overflow, question 481312, asked 2009-01; read 2026-10-29 (47 votes, 14810 views, 9 answers). | https://stackoverflow.com/questions/481312 |
| SO 2009f | "What's the most widely-used open source project that uses design by contract?". Stack Overflow, question 1634894, asked 2009-10; read 2026-10-29 (5 votes, 491 views, 1 answers). | https://stackoverflow.com/questions/1634894 |
| SO 2010a | "Presenting / explaing code and design decisions to team members". Stack Overflow, question 2278471, asked 2010-02; read 2026-10-28 (5 votes, 395 views, 3 answers). | https://stackoverflow.com/questions/2278471 |
| SO 2010b | "Differences between DFD (Data Flow Diagram) and activity diagram". Stack Overflow, question 3632859, asked 2010-09; read 2026-10-28 (29 votes, 55516 views, 5 answers). | https://stackoverflow.com/questions/3632859 |
| SO 2010c | "Does Conway's law hold?". Stack Overflow, question 2214468, asked 2010-02; read 2026-10-29 (4 votes, 368 views, 2 answers) | https://stackoverflow.com/questions/2214468 |
| SO 2011a | "Difference between Software Architecture document and System Design Document". Stack Overflow, question 5695039, asked 2011-04; read 2026-10-28 (6 votes, 4513 views, 1 answers). | https://stackoverflow.com/questions/5695039 |
| SO 2011b | "Writing pseudocode for parallel programming". Stack Overflow, question 5583257, asked 2011-04; read 2026-10-28 (29 votes, 27415 views, 7 answers). | https://stackoverflow.com/questions/5583257 |
| SO 2011c | "What is the UML analogue to the Data Flow Diagram from Structured Analysis?". Stack Overflow, question 7716196, asked 2011-10; read 2026-10-28 (34 votes, 52228 views, 8 answers). | https://stackoverflow.com/questions/7716196 |
| SO 2012a | "Are there any accepted standards for Architectural Diagram component types ? (Stereotypes for Architecture Diagram)". Stack Overflow, question 12513136, asked 2012-09; read 2026-10-28 (6 votes, 6229 views, 1 answers). | https://stackoverflow.com/questions/12513136 |
| SO 2012b | "Is there a human-readable and text-based representation of a Component diagram?". Stack Overflow, question 12125791, asked 2012-08; read 2026-10-28 (8 votes, 2922 views, 3 answers). | https://stackoverflow.com/questions/12125791 |
| SO 2012p | "CAP theorem - Availability and Partition Tolerance". Stack Overflow, question 12346326, asked 2012-09; read 2026-10-29 (340 votes, 125,926 views, 14 answers) | https://stackoverflow.com/questions/12346326 |
| SO 2012q | "Eventual consistency in plain English". Stack Overflow, question 10078540, asked 2012-04; read 2026-10-29 (175 votes, 45,142 views, 8 answers) | https://stackoverflow.com/questions/10078540 |
| SO 2012r | "Where does MongoDB stand in the CAP theorem?". Stack Overflow, question 11292215, asked 2012-07; read 2026-10-29 (169 votes, 107,605 views, 8 answers) | https://stackoverflow.com/questions/11292215 |
| SO 2014a | "Where to document database schema in arc42?". Stack Overflow, question 21681039, asked 2014-02; read 2026-10-28 (7 votes, 1664 views, 2 answers). | https://stackoverflow.com/questions/21681039 |
| SO 2014b | "arc42 template: Target architecture vs status quo". Stack Overflow, question 26286396, asked 2014-10; read 2026-10-28 (1 votes, 394 views, 1 answers). | https://stackoverflow.com/questions/26286396 |
| SO 2014c | "Solution architecture diagram - arrow directions". Stack Overflow, question 24947481, asked 2014-07; read 2026-10-28 (1 votes, 4685 views, 1 answers). | https://stackoverflow.com/questions/24947481 |
| SO 2014p | "Resources to learn solving system design interview problems". Stack Overflow, question 22027599, asked 2014-02; read 2026-10-29 (43 votes, 29,191 views, 1 answer) | https://stackoverflow.com/questions/22027599 |
| SO 2015a | "Why should I really use Property-based testing if I already practice Example-based testing?". Stack Overflow, question 30987599, asked 2015-06; read 2026-10-29 (8 votes, 3507 views, 2 answers). | https://stackoverflow.com/questions/30987599 |
| SO 2016a | "Is there an agreed UML diagram style for documenting or illustrating the role of (Docker) containers in a system architecture specification?". Stack Overflow, question 38270258, asked 2016-07; read 2026-10-28 (23 votes, 13971 views, 1 answers). | https://stackoverflow.com/questions/38270258 |
| SO 2016p | "Why isn't RDBMS Partition Tolerant in CAP Theorem and why is it Available?". Stack Overflow, question 36404765, asked 2016-04; read 2026-10-29 (75 votes, 31,201 views, 4 answers) | https://stackoverflow.com/questions/36404765 |
| SO 2018a | "Documenting an Event-Driven Architecture". Stack Overflow, question 50760313, asked 2018-06; read 2026-10-28 (21 votes, 4667 views, 1 answers). | https://stackoverflow.com/questions/50760313 |
| SO 2021a | "C4 model in practice". Stack Overflow, question 66633818, asked 2021-03; read 2026-10-28 (8 votes, 4132 views, 2 answers). | https://stackoverflow.com/questions/66633818 |
| SO 2021b | "Arrow direction for fetching data from database in architecture diagram?". Stack Overflow, question 66695185, asked 2021-03; read 2026-10-28 (20 votes, 18334 views, 3 answers). | https://stackoverflow.com/questions/66695185 |
| SO 2022a | "When should you write an architecture decision record (ADR)?". Stack Overflow, question 72107691, asked 2022-05; read 2026-10-28 (1 votes, 1844 views, 1 answers). | https://stackoverflow.com/questions/72107691 |
| Sobel 2002 | Sobel, Clarkson (2002). Formal methods application: an empirical tale of software development. IEEE Transactions on Software Engineering 28(3), 308-320. Abstract read; the numbers read in Berry 2003 | https://doi.org/10.1109/32.991322 |
| Sobel 2003 | Sobel, Clarkson (2003). Response to the comments on formal methods application. IEEE Transactions on Software Engineering 29(6), 572-575. Machine summary only; a journal index lists it under the title of the 2002 paper | https://doi.org/10.1109/TSE.2003.1205184 |
| Soh 2012 | Soh, Sharafi, Van den Plas, Cepeda Porras, Guéhéneuc, Antoniol (2012). Professional status and expertise for UML class diagram comprehension: an empirical study. ICPC | https://doi.org/10.1109/ICPC.2012.6240484 |
| Soliman 2025 | Soliman, Albonico, Malavolta, Wortmann (2025). Mining software repositories for software architecture: a systematic mapping study. Information and Software Technology 181, 107677 | https://doi.org/10.1016/j.infsof.2025.107677 |
| Soloway 1984 | Soloway, Ehrlich (1984). Empirical studies of programming knowledge. IEEE Transactions on Software Engineering | https://doi.org/10.1109/TSE.1984.5010283 |
| Soloway 1986 | Soloway (1986). Learning to program = learning to construct mechanisms and explanations. Communications of the ACM. One-sentence abstract read | https://doi.org/10.1145/6592.6594 |
| Soni 1995 | Soni, Nord, Hofmeister (1995). Software architecture in industrial applications. ICSE | https://doi.org/10.1145/225014.225033 |
| Spec Kit 2026 | GitHub (2026). Spec Kit: spec-driven development toolkit, readme; 143,670 stars and creation date 2025-08-21 read from the repository API on 2026-10-29. A vendor's own tool | https://web.archive.org/web/20261024051243/https://github.com/github/spec-kit |
| Spohrer 1985 | Spohrer, Soloway, Pope (1985). A goal/plan analysis of buggy Pascal programs. Human-Computer Interaction. Machine summary only | https://doi.org/10.1207/s15327051hci0102_4 |
| Starke 2026 | Starke, Hruschka (undated, read 2026). The arc42 template, twelve sections. Project site and template documentation | https://arc42.org/overview , https://docs.arc42.org/home/ |
| Starke 2026b | Starke (undated, read 2026). arc42 FAQ, question A-4: how widely is arc42 used | https://faq.arc42.org/questions/A-4/ |
| Steinmacher 2015 | Steinmacher, Graciotto Silva, Gerosa, Redmiles (2015). A systematic literature review on the barriers faced by newcomers to open source software projects. Information and Software Technology | https://doi.org/10.1016/j.infsof.2014.11.001 |
| Stevens 1974 | Stevens, Myers, Constantine (1974). Structured design. IBM Systems Journal. Located only: no abstract reached | https://doi.org/10.1147/sj.132.0115 |
| Störrle 2011 | Störrle (2011). On the impact of layout quality to understanding UML diagrams. VL/HCC | https://doi.org/10.1109/VLHCC.2011.6070390 |
| Störrle 2012 | Störrle (2012). On the impact of layout quality to understanding UML diagrams: diagram type and expertise. VL/HCC | https://doi.org/10.1109/VLHCC.2012.6344480 |
| Störrle 2013 | Störrle, Fish (2013). Towards an operationalization of the "physics of notations" for the analysis of visual languages. MODELS | https://doi.org/10.1007/978-3-642-41533-3_7 |
| Störrle 2014 | Störrle (2014). On the impact of layout quality to understanding UML diagrams: size matters. MODELS | https://doi.org/10.1007/978-3-319-11653-2_32 |
| Störrle 2016 | Störrle (2018). On the impact of size to the understanding of UML diagrams. Software and Systems Modeling 17 (online 2016) | https://doi.org/10.1007/s10270-016-0529-x |
| Störrle 2016b | Störrle (2016). Diagram size vs. layout flaws: understanding quality factors of UML diagrams. ESEM | https://doi.org/10.1145/2961111.2962609 |
| Störrle 2017 | Störrle (2017). How are conceptual models used in industrial software development? A descriptive survey. EASE | https://doi.org/10.1145/3084226.3084256 |
| Stylos 2007 | Stylos, Clarke (2007). Usability implications of requiring parameters in objects' constructors. ICSE, 529-539. Author copy read: 30 professional programmers. Open copy: http://www.cs.cmu.edu/~NatProg/papers/Stylos2007CreateSetCall.pdf | https://doi.org/10.1109/icse.2007.92 |
| Stylos 2008 | Stylos, Myers (2008). The implications of method placement on API learnability. FSE. Full text read | https://doi.org/10.1145/1453101.1453117 |
| Su 2024 | Su, Li, Taibi (2024). From microservice to monolith: a multivocal literature review. Electronics. Abstract read | https://doi.org/10.3390/electronics13081452 |
| Su 2026 | Su, Bakhtin, Ahmad, Esposito, Lenarduzzi, Taibi (2026). Evaluating large language models for detecting architectural decision violations. ICSA. Abstract partly read | https://doi.org/10.1109/ICSA66085.2026.00007 |
| Sun 2023 | Sun, Sheng, Padon, Barrett (2023). Clover: closed-loop verifiable code generation. Preprint; abstract read | https://arxiv.org/abs/2310.17807 |
| Sun 2024 | Sun (2024). Why pseudocode? Teaching CS newsletter | https://teachingcs.substack.com/p/why-pseudocode |
| Swift 2026 | Swift project (undated, read 2026). Swift Evolution: the evolution process | https://github.com/swiftlang/swift-evolution/blob/main/process.md |
| SysDesign Bench 2026 | SysDesign-Bench (repository). Benchmark of pre-code design decisions; found by search, not read | https://github.com/opheleon/SysDesign-Bench |
| Taibi 2017 | Taibi, Lenarduzzi, Pahl (2017). Processes, motivations, and issues for migrating to microservices architectures: an empirical investigation. IEEE Cloud Computing. Abstract read | https://doi.org/10.1109/mcc.2017.4250931 |
| Tang 2006 | Tang, Babar, Gorton, Han (2006). A survey of architecture design rationale. Journal of Systems and Software | https://doi.org/10.1016/j.jss.2006.04.029 |
| Tang 2010 | Tang, Aleti, Burge, van Vliet (2010). What makes software design effective? Design Studies. Summary line read (secondary); abstract not reached | https://doi.org/10.1016/j.destud.2010.09.004 |
| Tang 2012 | Tang, van Vliet (2012). Design strategy and software design effectiveness. IEEE Software. Abstract read in a search summary (secondary) | https://doi.org/10.1109/ms.2011.130 |
| Tang 2015 | Tang, van Vliet (2015). Software designers satisfice. ECSA, Lecture Notes in Computer Science 9278. Summary line read (secondary); abstract not reached | https://doi.org/10.1007/978-3-319-23727-5_9 |
| Tang 2017 | Tang, Razavian, Paech, Hesse (2017). Human aspects in software architecture decision making: a literature review. ICSA. Title and venue only | https://doi.org/10.1109/icsa.2017.15 |
| Tang 2024 | Tang, Sun, Huang, Wei, Ouyang and others (2024). SandTable: scalable distributed system model checking with specification-level state exploration. EuroSys. Forward snowball; abstract read | https://doi.org/10.1145/3627703.3650077 |
| Taylor 2025 | Taylor (2025-06-20, first published 2020). Best practices for creating architecture decision records (title taken from the page address; the page lists eight practices). TechTarget | https://techtarget.com/searchapparchitecture/tip/4-best-practices-for-creating-architecture-decision-records |
| Team Topologies 2026 | Team Topologies (read 2026-10-29). Key concepts. Project site | https://teamtopologies.com/key-concepts |
| ter Beek 2022 | ter Beek, Ferrari (2022). Empirical formal methods: guidelines for performing empirical studies on formal methods. Preprint; abstract only | https://arxiv.org/abs/2208.05266 |
| ter Beek 2024 | ter Beek, Chapman, Cleaveland, Garavel, Gu and others (2024). Formal methods in industry. Formal Aspects of Computing. Found by forward snowballing from Newcombe 2015; abstract read | https://doi.org/10.1145/3689374 |
| TeX FAQ 2026 | UK TeX FAQ (undated, read 2026). Typesetting pseudocode in LaTeX documents | https://texfaq.org/FAQ-algorithms |
| Theunissen 2022 | Theunissen, van Heesch, Avgeriou (2022). A mapping study on documentation in continuous software development. Information and Software Technology 142, 106733 | https://doi.org/10.1016/j.infsof.2021.106733 |
| ThoughtWorks 2014 | Thoughtworks Technology Radar (2014-07-08, Trial; not on the current edition). Inverse Conway maneuver | https://www.thoughtworks.com/radar/techniques/inverse-conway-maneuver |
| ThoughtWorks 2017 | Thoughtworks Technology Radar (2017-11-30, Trial; last edition May 2018). Architectural fitness function | https://www.thoughtworks.com/radar/techniques/architectural-fitness-function |
| ThoughtWorks 2018 | ThoughtWorks Technology Radar: lightweight architecture decision records (Trial 2016 and 2017, Adopt 2017 and 2018) | https://www.thoughtworks.com/radar/techniques/lightweight-architecture-decision-records |
| Thoughtworks 2020 | Thoughtworks (2020). Diagrams as code. Technology Radar, October 2020, ring Trial | https://www.thoughtworks.com/radar/techniques/diagrams-as-code |
| Thoughtworks 2025 | Thoughtworks (2025-11-05). Technology Radar: spec-driven development, ring Assess. Page read; it is no longer on the current edition. A company's own observation | https://web.archive.org/web/20261025121102/https://www.thoughtworks.com/radar/techniques/spec-driven-development |
| Tiwari 2023 | Tiwari et al. (2023). Machine learning for translating pseudocode to Python: a comprehensive review. ICICCS (title says review; the abstract read second-hand describes a proposed model) | https://doi.org/10.1109/iciccs56967.2023.10142254 |
| Tofan 2014 | Tofan, Galster, Avgeriou, Schuitema (2014). Past and future of software architectural decisions: a systematic mapping study. Information and Software Technology 56, 850-872. Abstract read | https://doi.org/10.1016/j.infsof.2014.03.009 |
| Toksoz 2024 | Toksoz, Tan, Giles (2024). Scaling automatic extraction of pseudocode. arXiv | https://arxiv.org/abs/2406.04635 |
| Tyree 2005 | Tyree, Akerman (2005). Architecture decisions: demystifying architecture. IEEE Software | https://doi.org/10.1109/ms.2005.27 |
| Ubl 2020 | Ubl (2020). Design docs at Google. Personal account of company practice | https://www.industrialempathy.com/posts/design-docs-at-google/ |
| UH 2026 | University of Houston COSC 3320 (undated, read 2026). Pythonic pseudocode guide and tutorial, marked work in progress | https://www2.cs.uh.edu/~panruowu/2024f_cosc3320/pythonic.html |
| Ulate-Caballero 2021 | Ulate-Caballero, Berrocal-Rojas, Hidalgo-Cespedes (2021). Concurrent and distributed pseudocode: a systematic literature review. CLEI | https://doi.org/10.1109/clei53233.2021.9640222 |
| UW 2023 | University of Washington CSE 421 (2023). Writing pseudocode. Course handout, author not named | https://courses.cs.washington.edu/courses/cse421/23au/resources/pseudocode.pdf |
| van der Linden 2018 | van der Linden, Hadar, Zamansky (2018). What practitioners really want: requirements for visual notations in conceptual modeling. Software and Systems Modeling 18(3) | https://doi.org/10.1007/s10270-018-0667-4 |
| van der Linden 2019 | van der Linden, Hadar (2019). A systematic literature review of applications of the Physics of Notations. IEEE TSE | https://doi.org/10.1109/TSE.2018.2802910 |
| van Heesch 2012 | van Heesch, Avgeriou, Hilliard (2012). Forces on architecture decisions: a viewpoint. WICSA/ECSA | https://doi.org/10.1109/wicsa-ecsa.212.18 |
| van Heesch 2012b | van Heesch, Avgeriou, Hilliard (2012). A documentation framework for architecture decisions. Journal of Systems and Software. Title and venue only | https://doi.org/10.1016/j.jss.2011.10.017 |
| van Heesch 2013 | van Heesch, Avgeriou, Tang (2013). Does decision documentation help junior designers rationalize their decisions? A comparative multiple-case study. Journal of Systems and Software 86(6), 1545-1565. Abstract read | https://doi.org/10.1016/j.jss.2013.01.057 |
| Vera-Rivera 2021 | Vera-Rivera, Gaona, Astudillo (2021). Defining and measuring microservice granularity: a literature overview. PeerJ Computer Science. Abstract read | https://doi.org/10.7717/peerj-cs.695 |
| Verdecchia 2021 | Verdecchia, Kruchten, Lago, Malavolta (2021). Building and evaluating a theory of architectural technical debt in software-intensive systems. Journal of Systems and Software. Abstract read | https://doi.org/10.1016/j.jss.2021.110925 |
| Viglioni 2024 | Viglioni, Batista, Cavalcante, Oquendo (2024). The execution perspective in software architecture descriptions: a systematic mapping. ECSA, LNCS, 379-395 | https://doi.org/10.1007/978-3-031-70797-1_26 |
| Viotti 2016 | Viotti, Vukolic (2016). Consistency in non-transactional distributed storage systems. ACM Computing Surveys 49(1), 1-34 | https://doi.org/10.1145/2926965 |
| Viviani 2021 | Viviani, Famelis, Xia, Janik-Jones, Murphy (2021). Locating latent design information in developer discussions: a study on pull requests. IEEE Transactions on Software Engineering | https://doi.org/10.1109/tse.2019.2924006 |
| Vokac 2004 | Vokac (2004). Defect frequency and design patterns: an empirical study of industrial code. IEEE TSE. Abstract read in a library record (secondary) | https://doi.org/10.1109/tse.2004.99 |
| Waddel 1988 | Waddel, Cross (1988). Survey of empirical studies of graphical representations for algorithms. ACM CSC | https://doi.org/10.1145/322609.323161 |
| Wan 2023 | Wan, Zhang, Xia, Jiang, Lo (2023). Software architecture in practice: challenges and opportunities. ESEC/FSE | https://doi.org/10.1145/3611643.3616367 |
| Wang 2020 | Wang, Kuo, Li, Zeller (2020). Assessing and restoring reproducibility of Jupyter notebooks. ASE | https://doi.org/10.1145/3324884.3416585 |
| Ware 2002 | Ware, Purchase, Colpoys, McGill (2002). Cognitive measurements of graph aesthetics. Information Visualization | https://doi.org/10.1057/palgrave.ivs.9500013 |
| Warsaw 2000 | Warsaw, Hylton, Goodger, Coghlan (2000). PEP 1: PEP purpose and guidelines | https://peps.python.org/pep-0001/ |
| Waterman 2015 | Waterman, Noble, Allan (2015). How much up-front? A grounded theory of agile architecture. ICSE. Abstract read in the IEEE listing (via a search summary) | https://doi.org/10.1109/icse.2015.54 |
| Wayne 2019 | Wayne (2019-01-21). Why don't people use formal methods? Blog essay. Read 2026-10-29 | https://www.hillelwayne.com/post/why-dont-people-use-formal-methods/ |
| Weinreich 2014 | Weinreich, Groher (2014). A fresh look at codification approaches for SAKM: a systematic literature review. ECSA, Lecture Notes in Computer Science. Title and venue only | https://doi.org/10.1007/978-3-319-09970-5_1 |
| Weinreich 2015 | Weinreich, Groher, Miesbauer (2015). An expert survey on kinds, influence factors and documentation of design decisions in practice. Future Generation Computer Systems | https://doi.org/10.1016/j.future.2014.12.002 |
| Weinreich 2016 | Weinreich, Groher (2016). Software architecture knowledge management approaches and their support for knowledge management activities: a systematic literature review. Information and Software Technology 80, 265-286 | https://doi.org/10.1016/j.infsof.2016.09.007 |
| Wet 1990 | Wet (1990). Comments, with reply, on 'Structured flowcharts outperform pseudocode: an experimental comparison' (with a reply by Scanlan). IEEE Software | https://doi.org/10.1109/52.43063 |
| Wikipedia 2026a | Wikipedia: Pseudocode (read 2026-10-28) | https://en.wikipedia.org/wiki/Pseudocode |
| Wikipedia 2026b | Wikipedia (read 2026). Data-flow diagram (symbol sets of DeMarco, Yourdon, Gane and Sarson) | https://en.wikipedia.org/wiki/Data-flow_diagram |
| Wirth 1971 | Wirth (1971). Program development by stepwise refinement. Communications of the ACM | https://doi.org/10.1145/362575.362577 |
| Woodcock 2009 | Woodcock, Larsen, Bicarregui, Fitzgerald (2009). Formal methods: practice and experience. ACM Computing Surveys 41(4), article 19. A preprint copy was read for section 3 | https://doi.org/10.1145/1592434.1592436 |
| Wyrich 2023 | Wyrich, Bogner, Wagner (2023). 40 years of designing code comprehension experiments: a systematic mapping study. ACM Computing Surveys | https://doi.org/10.1145/3626522 |
| Xiao 2014 | Xiao, Cai, Kazman (2014). Design rule spaces: a new form of architecture insight. ICSE. Abstract read | https://doi.org/10.1145/2568225.2568241 |
| Yuan 2014 | Yuan, Luo, Zhuang, Rodrigues, Zhao, Zhang, Jain, Stumm (2014). Simple testing can prevent most critical failures: an analysis of production failures in distributed data-intensive systems. OSDI | https://www.usenix.org/conference/osdi14/technical-sessions/presentation/yuan |
| Yusuf 2007 | Yusuf, Kagdi, Maletic (2007). Assessing the comprehension of UML class diagrams via eye tracking. ICPC | https://doi.org/10.1109/ICPC.2007.10 |
| Zalando 2026 | Zalando SE API Guild (page read 2026-10-29, first 100,000 characters). Zalando RESTful API and event guidelines | https://opensource.zalando.com/restful-api-guidelines/ |
| Zanaty 2018 | Zanaty, Hirao, McIntosh, Ihara, Matsumoto (2018). An empirical study of design discussions in code review. ESEM | https://doi.org/10.1145/3239235.3239525 |
| Zannier 2007 | Zannier, Chiasson, Maurer (2007). A model of design decision making based on empirical results of interviews with software designers. Information and Software Technology. Summary line read (secondary); abstract not reached | https://doi.org/10.1016/j.infsof.2007.02.010 |
| Zarzycki 2026 | Zarzycki (2026). What open-source projects tell their coding agents: a census of AGENTS.md and CLAUDE.md. Preprint, version 2 | arXiv:2610.31715 |
| Zdun 2013 | Zdun, Capilla, Tran, Zimmermann (2013). Sustainable architectural design decisions. IEEE Software | https://doi.org/10.1109/ms.2013.97 |
| Zhang 2012 | Zhang, Budgen (2012). What do we know about the effectiveness of software design patterns? IEEE TSE. Abstract read | https://doi.org/10.1109/tse.2011.79 |
| Zhang 2023 | Zhang, Chen, Shen, Ding, Tenenbaum, Gan (2023). Planning with large language models for code generation. Preprint; abstract read | https://arxiv.org/abs/2303.05510 |
| Zhi 2015 | Zhi, Garousi-Yusifoğlu, Sun, Garousi, Shahnewaz, Ruhe (2015). Cost, benefits and quality of software development documentation: a systematic mapping. Journal of Systems and Software 99, 175-198 | https://doi.org/10.1016/j.jss.2014.09.042 |
| Zhou 2021 | Zhou, Xu, Shraer, Namasivayam and others (2021). FoundationDB: a distributed unbundled transactional key value store. SIGMOD, 2653-2666. Author copy read: abstract and the simulation testing section. Open copy: https://www.foundationdb.org/files/fdb-paper.pdf | https://doi.org/10.1145/3448016.3457559 |
| Zhumagambetov 2021 | Zhumagambetov (2021). Teaching formal methods in academia: a systematic literature review. Communications in Computer and Information Science. Abstract only | https://doi.org/10.1007/978-3-030-71374-4_12 |