References

Terence Parr (2013). The Definitive ANTLR 4 Reference. Pragmatic Bookshelf.

Dmitri Borgmann (1967). Beyond Language: Adventures in Word and Thought. Charles Scribner's Sons.

Mark Christiansen (2013). Adobe After Effects CC Visual Effects and Compositing Studio Techniques. Adobe Press.

Jonathan Aldrich, Michael Coblenz (2020). Notes for Carnegie Mellon 17-396/696/960: Language Design and Prototyping. https://www.cs.cmu.edu/~aldrich/courses/17-396/.

Noam Chomsky (1965). Aspects of the Theory of Syntax. MIT Press.

Arcadi Grigorian, Paul Fang, Tate Kirk, Aslan Efendizade, Jami Jadidi, Maziar Sighary, and Dan Cohen-Addad (2020). Learning from gamers: integrating alternative input devices and AutoHotkey scripts to simplify repetitive tasks and improve workflow. Radiographics.

Carolyn Ellis, Tony Adams, and Arthur Bochner (2011). Autoethnography: an Overview. JSTOR.

C.A.R. Hoare (1969). An Axiomatic Basis for Computer Programming. Communications of the ACM.

Martin Richards, Colin Whitby-Srtevens (1979). BCPL - The language and its compiler. Cambridge University Press.

Green, Thomas RG. (1989). Cognitive Dimensions of Notation. People and Computers.

Blackwell, Alan F., et al. (2001). Cognitive dimensions of notations: Design tools for cognitive technology. Cognitive Technology.

Blackwell, Alan, and Thomas Green (2003). Notational systems–the cognitive dimensions of notations framework. HCI models, theories, and frameworks: toward an interdisciplinary science..

Brian Kernighan and Dennis Ritche (2002). The C Programming Language. Pearson.

Bjarne Stroustrup (2013). The C++ Programming Language. Pearson Education.

4chan trolls (2014). C Plus Equality. GitHub.

Pascal van Hentenryck (1989). Constraint satisfaction in logic programmnig. MIT Press.

Haakon Wium Lie and Bert Bos (1997). Cascading style sheets: designing for the Web. Addison-Wesley Longman.

Itiroo Sakai (1961). Syntax in Universal Translation . International Conference on Machine Translation of Languages and Applied Language Analysis.

OpenAI (2022). ChatGPT. OpenAI.

Alain Strowel (2023). ChatGPT and Generative AI Tools: Theft of Intellectual Labor?. Springer.

Michael Coblenz (2022). Notes for UC San Diego CSE 2911: Usability of Programming Languages. https://cseweb.ucsd.edu/~mcoblenz/teaching/.

Tiffany Gallicano (2013). An Example of How to Perform Open Coding, Axial Coding, and Selective Coding. https://prpost.wordpress.com/2013/07/22/an-example-of-how-to-perform-open-coding-axial-coding-and-selective-coding/.

Douglas Thain (2019). Introduction to Compilers and Language Design. Self-published.

William Waite and Gerhard Goos (2012). Compiler Construction. Springer Science & Business Media.

Anthony Oettinger (1966). The Uses of Computing in Science. Scientific American.

Tobias Nipkow and Gerwin Klein (2014). Concrete Semantics: with Isabelle/HOL. Springer.

Kathy Charmaz (2014). Constructing Grounded Theory. Sage.

Mark Lentczner, Chris Coyne, and Josh Horigan (2005). Context Free Art. https://www.contextfreeart.org/.

GitHub (2021). Copilot. GitHub.

Guy Blelloch and John Greiner (1995). Parallelism in sequential functional languages. Functional Programming Languages and Computer Architecture.

Aimi Hamraie and Kelly Fritsch (2019). Crip technoscience manifesto. Catalyst: feminism, theory, technoscience.

Miles Macleod and Ralph Rengger (1993). The Development of DRUM: A Software Tool for Video-assisted Usability. People and Computers.

Arie van Deuren, Paul Klint, and Joost Visser (2000). Domain-specific languages: An annotated bibliography. ACM.

Dana Scott (1982). Demains for Denotational Semantics. Automata, Languages, and Programming.

Theresa Tanenbaum (2014). Design fictional interactions: why HCI should care about stories. Interactions.

Thomas Shakespeare (2017). Disability: The Basics. Routledge.

Katta Spiel, Kathrin Gerling, Cynthia L. Bennett, Emeline Brulé, Rua M. Williams, Jennifer Rode, and Jennifer Mankoff (2020). Nothing about us without us: Investigating the role of critical disability studies in HCI. CHI Extended Abstracts.

Lennard J Davis (2006). The disability studies reader. Taylor & Francis.

Jay Earley (1968). An Efficient Context-Free Parsing Algorithm. Carnegie-Mellon University.

Carl Gunter (1996). Algebraic Semantics of Imperative Programming Languages. MIT Press.

John Brewer (2000). Ethnography. McGraw-Hill Education (OK).

Simon Peyton Jones, Alan Blackwell, and Margaret Burnett (2003). A user-centred approach to functions in Excel. ACM SIGPLAN International Conference on Functional Programming.

Li, Haoyi (2024). Fastparse, version 3.0.1. https://com-lihaoyi.github.io/fastparse/.

Valentina Grigoreanu, Jill Cao, Todd Kulesza, Christopher Bogart, Kyle Rector, Margaret Burnett, and Susan Wiedenbeck (2008). Can Feature Design Reduce the Gender Gap in End-User Software Development Environments?. Visual Languages and Human-Centric Computing.

Andrea Long Chu (2019). Females. Verso Books.

Ari Schlesinger (2014). A Feminist Programming Language. FemTechNet.

micha cárdenas (2014). femme Disturbance library. Unpublished.

John Levine (2009). Flex & Bison: Text Processing Tools. O'Reilly Media, Inc.

Sperry Rand Corporation (1957). Introducing a New Language for Automatic Programming: Univac Flow-Matic. Sperry Rand Corporation.

Nico Lehmann, Adam Geller, Niki Vazou, and Ranjit Jhala (2023). Flux: Liquid Types for Rust. Programming Language Design and Implementation.

Richard Stallman and the GCC Developer Community (2018). GNU 8.0 GNU Compiler Collection Internals. GNU Project.

Masaru Tomita (1984). LR Parsers for Natural Languages. International Conference on Computational Linguistics.

Randi J. Rost, Bill Licea-Kane, Dan Ginsburg, John Kessenich, Barthold Lichtenbelt, Hugh Malan, and Mike Weiblen (2009). OpenGL Shading Language. Pearson Education.

Eric Holk, Milinda Pathirage, Arun Chauhan, Andrew Lumsdaine, and Nicholas D. Matsakis (2013). GPU Programming in Rust: Implementing High-Level Abstractions in a Systems-Level Language. IEEE International Symposium on Parallel & Distributed PRocessing.

Margaret Burnett, Simone Stumpf, Jamie Macbeth, Stephann Makri, Laura Beckwith, Irwin Kwan, Anicia Peters, and William Jernigan (2016). GenderMag: A method for evaluating software's gender inclusiveness. Interacting With Computers.

Judith Butler (2011). Gender trouble: Feminism and the subversion of identity. Routledge.

Kate Bornstein (1998). My gender workbook: How to become a real man, a real woman, the real you, or something else entirely. Psychology Press.

Michael Coblenz (2017). Glacier: Transitive Class Immutability for Java. International Conference on Software Engineering.

Nivedita Bhirud (2017). Grammar checkers for natural languages: a review. International Journal on Natural Language Computing.

Morgan Klaus Scheuerman, Katta Spiel, Oliver L. Haimson, Foad Hamidi, Stacy M. Branham (2020). HCI Guidelines for Gender Equity and Inclusivity. https://www.morgan-klaus.com/gender-guidelines.html.

Jennifer Niederst Robbins (2012). Learning Web Design: A beginner's guide to HTML, CSS, JavaScript, and web graphics. O'Reilly Medio, Inc..

Li, Haoyi (2020). Hands-on Scala Programming: Learn Scala in a Practical, Project-Based Way. Self-Published.

A. P. Ershov (1958). On programming of arithmetic operations. Communications of the ACM.

Simon Peyton Jones (2003). Haskell 98 Language and Libraries: The Revised Report. Cambridge University Press.

RosettaCode contributors (2023). Hello world (newbie). https://rosettacode.org/wiki/Hello_world/Newbie.

John McCarthy (1978). History of LISP. History of Programming Languages.

Grace Hopper (1959). Automatic programming: Present status and future trends. National Physical Laboratory Symposium.

Leif Andersen, Michael Ballantyne, and Matthias Felleisen (2020). Adding Interactive Visual Syntax to Textual Code.. OOPSLA.

International Standards Organization (2018). Ergonomics of human-system interaction — Part 11: Usability: Definitions and concept. ISO 9241-11:2018(en).

Rose Bohrer (2022). Imagining Introductory Rust. https://rust-edu.github.io/workshop/proceedings.pdf.

Coblenz, M., Sunshine, J., Aldrich, J., Myers, B., Weber, S. and Shull, F. (2016). Exploring language support for immutability. International Conference on Software Engineering.

Microsoft Inclusive Design Team (2023). Inclusive Design for Cognition Guidebook. Microsoft.

Christopher Mendez, Lara Letaw, Margaret Burnett, Simone Stumpf, Anita Sarma, and Claudia Hilderbrand (2019). From GenderMag to InclusiveMag: An inclusive design meta-method. Visual Languages and Human-Centric Computing.

Charles Hill, Maren Haag, Alannah Oleson, Chris Mendez, Nicola Marsden, Anita Sarma, and Margaret Burnett (2017). Gender-Inclusiveness Personas vs. Stereotyping: Can We Have it Both Ways?. https://dl.acm.org/doi/pdf/10.1145/3025453.3025609.

Margaret Burnett, Martin Erwig, Abrar Fallatah, Christopher Bogart, Anita Sarma (2022). Intersectionality Goes Analytical: Taming Combinatorial Explosion Through Type Abstraction. https://arxiv.org/abs/2201.10643.

Giulia Barbareschi and Dafne Zuleima Morgado Ramirez (2020). Individuality over function: the role of technology in disability identity. CHI 2020 Extended Abstracts.

Graham Nelson, et. al. (2023). Inform book. https://ganelson.github.io/inform-website/book.

Graham Nelson (2006). Natural language, semantic analysis, and interactive fiction. IF Theory Reader.

Alan Cooper (1999). The inmates are running the asylum. Springer.

John Aycock (2003). A brief history of just-in-time. ACM Computing Surveys.

Tim Lindholm, Frank Yellin, Gilad Bracha, and Alex Buckley (2014). The Java Virtual Machine Specification. Pearson Education.

Danielle Sucher (2014). Jailbreak the Patriarchy. https://chrome.google.com/webstore/detail/jailbreak-the-patriarchy/fiidcfoaaciclafodoficaofidfencgd.

Ken Arnold and James Gosling (1996). The Java Programming Language. Addison-Wesley.

Franklin DeRemer (1969). Practical Translators for LR(k) Languages. MIT.

Thorsten Brants, Ashok Popat, Peng Xu, Franz Och, and Jeffrey Dean (2007). Large language models in machine translation. EMNLP.

Chris Lattner and Vikram Adve (2004). LLVM: A compilation framework for lifelong program analysis & transformation. IEEE Symposium on Code Generation and Optimization.

John Levine, John Mason, Tony Mason, Doug Brown, Paul Levine (1992). Lex & Yacc. O'Reilly Media.

George Dantzig (2002). Linear Programming. Operations Research.

Donald Knuth (1984). Literate programming. Oxford University Press.

John Lloyd (2012). Foundations of Logic Programming. Springer Science & Business Media.

Michel Benichou, Jean-Michel Gauthier, Paul Girodet, Gerard Hentges, Gerard Ribiere, and Olivier Vincent (1971). Experiments in mixed-integer linear programming. Mathematical Programming.

G. Kane and J. Heinrich (1992). MIPS RISC Architectures. https://dl.acm.org/doi/abs/10.5555/121079.

Nicolas Lagaillardie, Rumyana Neykova, and Nobuko Yoshida (2022). Stay safe under panic: Affine rust programming with multiparty session types. arXiv preprint arXiv:2204.13464.

Nigel Bevan (1995). Measuring usability as quality of use. Software Quality Journal.

Matthew Fluet, Lars Bergstrom, Nic Ford, Mike Rainey, John Reppy, and Shaw, Adam and Yingqi Xiao (2010). Programming in Manticore, a heterogenous parallel functional language. Central European Functional Programming School.

Stephen H. Kan (2003). Metrics and models in software quality engineering. Addison-Wesley Professional.

Mez Breeze (1994). Mezangelle. Kajplats 305 and elsewhere.

Krzysztof Cwalina (2004). Designing .NET Class Libraries. Web Archive.

Stefan K. Muller (2021). Responsive Parallel Computation. https://doi.org/10.1184/r1/16826782.v1.

John Gough (2001). Compiling for the .NET Common Language Runtime. 2001.

KR Chowdhary (2020). Natural language processing. Fundamentals of artificial intelligence.

Kate Bornstein (2013). My new gender workbook: A step-by-step guide to achieving world peace through gender anarchy and sex positivity. Routledge.

Will Crichton (2020). The Usability of Ownershi. arXiv preprint.

Kathleen Fisher and Robert Gruber (2005). PADS: A domain-specific language for processing ad hoc data. ACM SIGPLAN Conference on Programming Language Design and Implementation .

Bryan Ford (2004). Parsing Expression Grammars: A recognition-based syntactic foundation. Principles of Programming Languages.

Robert Harper (2016). Practical Foundations for Programming Languages. Cambridge University Press.

Coblenz, M., Kambhatla, G., Koronkevich, P., Wise, J.L., Barnaby, C., Sunshine, J., Aldrich, J. and Myers, B.A. (2021). PLIERS: a process that integrates user-centered methods into programming language design.. Transactions on Computer-Human Interaction.

Clay Spinuzzi (2005). The methodology of participatory design. Technical Communication.

Katherine Ye, Wode Ni, Max Krieger, Dor Ma'ayan, Jenna Wise, Jonathan Aldrich, Joshua Sunshine, and Keenan Crane (2020). Penrose: From Mathematical Notation to Beautiful Diagrams. ACM Trans. Graph..

Penrose developers (2020). Penrose Web Interface. https://penrose.cs.cmu.edu/try/.

Penrose developers (2020). Penrose Tutorial. https://penrose.cs.cmu.edu/docs/tutorial/welcome.

Ian Bogost (2010). Persuasive Games: The expressive power of videogames. MIT Press.

Faily, S. and Flechais, I. (2011). Persona Cases: A Technique for Grounding Personas. Computer Human Interaction.

Margaret Price and Doug Kim (2018). Kill Your Personas. Microsoft Design via Medium.

Robin Milner, Joachim Parrow, and David Walker (1992). A Calculus of Mobile Processes. Information and Computation.

Nicodemos Damianou, Naranker Dulay, Emil Lupu, and Morris Sloman (2001). The Ponder policy specification language. Policies for Distributed Systems and Networks.

David Thomas and Andrew Hunt (1999). The Pragmatic Programmer. Addison-Wesley Professional.

Processing Foundation (2023). Processing.org. processing.org.

Casey Reas and Ben Fry (2006). Processing: programming for the media arts. AI & Society.

Brad Myers, Amy Ko, Thomas LaToza, YoungSeok Yoon (2016). Programmers Are Users Too: Human-Centered Methods for Improving Programming Tools. IEEE Computer.

Alexandra To, Hillary Carey, Riya Shrivastava, Jessica Hammer, and Geoff Kaufman (2022). Interactive fiction provotypes for coping with interpersonal racism. CHI.

Brian Kernighan and Rob Pike (1999). The Practice of Programming. Addison-Wesley Professional.

Guido van Rossum, et. al. (2007). Python Programming Language. USENIX Annual Technical Conference.

Ahmed Seffah, Mohammad Donyaee, Rex B. Kline, Harkirat K. Padda (2006). Usability measurement and metrics: A consolidated model. Software Quality Journal.

Jorge Nocedal and Stephen Wright (2007). QuadraticProgramming. Numerical Optimization.

Greg Walsh for id Softawre (1999). Quake III Arena. Software Heritage Archive.

Koen Claessen and John Hughes (2000). QuickCheck: a lightweight tool for random testing of Haskell programs. International Conference on Functional Programming.

Jan Hoffmann, Klaus Aehlig, and Martin Hofmann (2012). Resource aware ML. CAV.

Lola Young (1999). Racializing femininity. Women’s Bodies: Discipline and Transgression.

Matthias Felleisen, Robert Findler, Matthew Flatt, Shriram Krishnamurthi, Eli Barzilay, Jay McCarthy, and Sam Tobin-Hochstadt (2015). The Racket Manifesto. SNAPL.

Andreas Stefik and Susanna Siebert (2013). An Empirical Investigation into Programming Language Syntax. ACM Transactions on Computing Education.

Rust Team (2023). Documentation for crate regex. https://docs.rs/regex/latest/regex/ 1.8.4.

Linda Macaulay (1996). Requirement Engineering. Springer.

Cynthia Coburn and William Penuel (2016). Research-practice partnerships in education: Outcomes, Dynamics, and Open Questions. Sage CA.

Margaret Price & Doug Kim (2023). Respecting Focus. Microsoft.

Kevin Brock (2019). Rhetorical Code Studies: Discovering arguments in and around code. University of Michigan Press.

Steve Klabnik and Carol Nichols (2023). The Rust Programming Language. No Starch Press.

Anna Zeng and Will Chrichton (2018). Identifying Barriers to Adoption for Rust through Online Discourse. PLATEAU@SPLASH 2018.

Rust Team (2023). Rust By Example. https://doc.rust-lang.org/rust-by-example/.

Rust Team (2023). Rust Documentation. https://doc.rust-lang.org/std/.

Rust-Edu Org (2022). Rust Education Workshop. https://rust-edu.github.io/workshop/proceedings.pdf.

Kevin Mehal (2022). Rust peg crate, version 0.8.1. https://crates.io/crates/peg.

Rust Team (2023). Rust Playground. https://play.rust-lang.org/.

Jose Duarte and Antonio Ravara (2021). Retrofitting Typestates into Rust. Brazillian Symposium on Programming Languages.

Marcelo Almeida, et. al. (2022). RustViz: Interactively Visualizing Ownership and Borrowing. IEEE Symposium on Visual Languages and Human-Centric Computing.

Miles Macleod (1994). Usability: practical methods for testing and improvement. Norwegian Computer Society Software Conference.

Jeff Bonwick (1994). The slab allocator: An object-caching kernel memory allocator. USENIX Summer.

Gordon Plotkin (2004). The origins of Structural Operational Semantics. Journal of Logic and Algebraic Programming.

Thomas Bracht Laumann Jespersen, Philip Munksgaard, and Ken Friis Larsen (2015). Session Types for Rust. ACM SIGPLAN Workshop on Generic Programming.

Kirakowski, J. and M. Corbett (1993). SUMI: The software usability measurement inventory. British Journal of Education Technology.

J. Kirakowski (1996). The software usability measurement inventory: background and usage. Usability Evaluation in Industry.

Bangor, Aaron, Philip T. Kortum, and James T. Miller (2008). An empirical evaluation of the system usability scale. International Journal of Human-Computer Interaction.

Meiyuzi Gao, Philip Kortum, and Frederick L. Oswald (2020). Multi-Language Toolkit for the System Usability Scale. International Journal of Human–Computer Interaction.

James R. Lewis (2018). The System Usability Scale: Past, Present, and Future. International Journal of Human–Computer Interaction .

Philip Kortum and Frederick L. Osward (2018). The impact of personality on the subjective assessment of usability. International Journal of Human-Computer Interaction.

Jeff Sauro and James R. Lewis (2011). When designing usability questionnaires, does it hurt to be positive?. Proceedings of the SIGCHI conference on human factors in computing systems.

Benjamin Lamowski, Carsten Weinhold, Adam Lackoryzynski, and Hermann Haertig (2017). Sandcrust: Automatic Sandboxing of Unsafe Components in Rust. Workshop on Programming Languages and Operating Systems.

Processing Foundation (2023). Saturation. https://processing.org/examples/saturation.html.

EPFL and Lightbend (2023). Scala regex documentation. https://www.scala-lang.org/api/2.13.4/scala/util/matching/Regex.html.

Umut Acar (2005). Self-Adjusting Computation. Carnegie Mellon University.

Walaa Medhat, Ahmed Hassan, and Hoda Korashy (2014). Sentiment analysis algorithms and applications: A survey. Elsevier.

P. Guenther and T. Showalter (2008). Sieve: An email filtering language. Internet Society RFC 5228.

Micael Sipser (1996). Introduction to the Theory of Computation. PWS Pub. Co..

Daniel Jurafsky and James Martin (2000). Speech and Language Processing: An introduction to Natural Language Processing, Computational Linguistics, and Speech Recognition. Prentice Hall.

N Marsden, M Haag (2016). Stereotypes and politics: reflections on personas. Computer-Human Interaction.

Turner, P. and Turner, S. (2011). Is stereotyping inevitable when designing with personas?. Design Studies.

Donald Palmer (2007). Structuralism and poststructuralism for beginners. Red Wheel/Weiser.

Noam Chomsky (1957). Syntactic Structures. De Gruyter Mouton.

Karl Crary, Neal Glew, Dan Grossman, Richard Samuels, F Smith, D Walker, S Weirich, and S Zdancewic (1999). TALx86: A realistic typed assembly language. ACM SIGPLAN Workshop on Compiler Support for System Software.

Benjamin Pierce (2002). Types and Programming Languages. MIT Press.

Virginia Braun and Victoria Clarke (2012). Thematic Analysis. American Psychological Association.

Cecily Morrison, Nicolas Villar, Anja Thieme, Zahra Ashktorab, Eloise Taysom, Oscar Salandin, Daniel Cletheroe, Greg Saul, Alan F Blackwell, Darren Edge, Martin Grayson, and Haiyan Zhang (2018). Torino: A Tangible Programming Language Inclusive of Children with Visual Disabilities. Human-Computer Interaction .

David B Cruz (2015). Transgender rights after Obergefell. MKC Law Review.

Interactive Fiction Technology Foundation (2023). Twine 2.6.2. twinery.org.

Amy J. Ko and Brad A. Myers (2004). Designing the whyline: a debugging interface for asking questions about program behavior. SIGCHI conference on Human factors in computing systems.

Nadia Eghbal (2020). Working in Public: The making and maintenance of open source software. Stripe Press.

Tim Bray, Jean Paoli, C. Michael Sperberg-McQueen, Eve Maler, Francois Yergeau, John Cowan (1998). Extensible Markup Language (XML) 1.0. W3C.