arXiv subjects

Ryan E. Dougherty

Publications and source records attributed to Ryan E. Dougherty.

12 recordsLinked to original sources

arXiv2026

A Vision for the Future of an AI-Integrated Research Ecosystem

Generative AI has infiltrated every stage of the research lifecycle: how scholarship is conducted, written, published, and reviewed. Recent policy responses, such as ACM's authorship policy, address an immediate concern about responsible and transparent disclosure of AI use. We argue that a focus on authorship and disclosure, although necessary, risks obscuring and ballooning a set of entrenched problems and strains within publication systems. The central question is not about how papers and other research artifacts should incorporate AI, but how scientific communication itself should evolve when all relevant parties (authors, reviewers, readers) may rely on AI assistance. We draw on our experience within these and other roles to illustrate two contrasting but feasible visions of 2036 with four entwined questions, namely about the purpose of papers as artifacts, reviews, human reviewers, and the incentives that bind all of them. We argue for a shift from policing GenAI and other disruptive technologies to building the infrastructure of provenance, calibration, and accountability that would make trustworthy scholarship the default. We conclude with three grand challenges and invite the community to a broader conversation and research pathways.

cs.CY↗

arXiv2024

Scaffolding Research Projects in Theory of Computing Courses

Theory of Computing (ToC) is an important course in CS curricula because of its connections to other CS courses as a foundation for them. Traditional ToC course grading schemes are mostly exam-based, and sometimes a small weight for traditional proof-type assignments. Recent work experimented with a new type of assignment, namely a ``mock conference'' project wherein students approach and present ToC problems as if they were submitting to a ``real'' CS conference. In this paper we massively scaffold this existing project and provide our experiences in running such a conference in our own ToC course.

cs.CY↗

arXiv2024

Finite State Machine with Input and Process Render

Finite State Machines are a concept widely taught in undergraduate theory of computing courses. Educators typically use tools with static representations of FSMs to help students visualize these objects and processes; however, all existing tools require manual editing by the instructor. In this poster, we created an automatic visualization tool for FSMs that generates videos of FSM simulation, named Finite State Machine with Input and Process Render (FSMIPR). Educators can input any formal definition of an FSM and an input string, and FSMIPR generates an accompanying video of its simulation. We believe that FSMIPR will be beneficial to students who learn difficult computer theory concepts. We conclude with future work currently in-progress with FSMIPR.

cs.CY↗

arXiv2024

Can ChatGPT Pass a Theory of Computing Course?

Large Language Models (LLMs) have had considerable difficulty when prompted with mathematical questions, especially those within theory of computing (ToC) courses. In this paper, we detail two experiments regarding our own ToC course and the ChatGPT LLM. For the first, we evaluated ChatGPT's ability to pass our own ToC course's exams. For the second, we created a database of sample ToC questions and responses to accommodate other ToC offerings' choices for topics and structure. We scored each of ChatGPT's outputs on these questions. Overall, we determined that ChatGPT can pass our ToC course, and is adequate at understanding common formal definitions and answering "simple"-style questions, e.g., true/false and multiple choice. However, ChatGPT often makes nonsensical claims in open-ended responses, such as proofs.

cs.CY↗

arXiv2023

Designing Theory of Computing Backwards

The design of any technical Computer Science course must involve its context within the institution's CS program, but also incorporate any new material that is relevant and appropriately accessible to students. In many institutions, theory of computing (ToC) courses within undergraduate CS programs are often placed near the end of the program, and have a very common structure of building off previous sections of the course. The central question behind any such course is ``What are the limits of computers?'' for various types of computational models. However, what is often intuitive for students about what a ``computer'' is--a Turing machine--is taught at the end of the course, which necessitates motivation for earlier models. This poster contains our experiences in designing a ToC course that teaches the material effectively ``backwards,'' with pedagogic motivation of instead asking the question ``What suitable restrictions can we place on computers to make their problems tractable?'' We also give recommendations for future course design.

cs.CY↗

arXiv2023

Creation of a CS1 Course with Modern C++ Principles

Best practices in programming need to be emphasized in a CS1 course as bad student habits persist if not reinforced well. The C++ programming language, although a relatively old language, has been regularly updated with new versions since 2011, on the pace of once every three years. Each new version contains important features that make the C++ language more complex for backwards compatibility, but often introduce new features to make common use cases simpler to implement. This poster contains experiences in designing a CS1 course that uses the C++ programming language that incorporates ``modern'' versions of the language from the start, as well as recent conferences about the language. Our goals were to prevent many common bad habits among C++ programmers.

cs.CY↗

arXiv2023

Faster Location in Combinatorial Interaction Testing

Factors within a large-scale software system that simultaneously interact and strongly impact the system's response under a configuration are often difficult to identify. Although screening such a system for the existence of such interactions is important, determining their location is more useful for system engineers. Combinatorial interaction testing (CIT) concerns creation of test suites that nonadaptively either detect or locate the desired interactions, each of at most a specified size or show that no such set exists. Under the assumption that there are at most a given number of such interactions causing such a response, locating arrays (LAs) guarantee unique location for every such set of interactions and an algorithm to deal with outliers and nondeterministic behavior from real systems, we additionally require the LAs to have a "separation" between these collections. State-of-the-art approaches generate LAs that can locate at most one interaction of size at most three, due to the massive number of interaction combinations for larger parameters if no constraints are given. This paper presents LocAG, a two-stage algorithm that generates (unconstrained) LAs using a simple, but powerful partitioning strategy of these combinations. In particular, we are able to generate LAs with more factors, with any desired separation, and greater interaction size than existing approaches.

cs.DM↗

arXiv2023

Experiences with Research Processes in an Undergraduate Theory of Computing Course

Theory of computing (ToC) courses are a staple in many undergraduate CS curricula as they lay the foundation of why CS is important to students. Although not a stated goal, an inevitable outcome of the course is enhancing the students' technical reading and writing abilities as it often contains formal reasoning and proof writing. Separately, many undergraduate students are interested in performing research, but often lack these abilities. Based on this observation, we emulated a common research environment within our ToC course by creating a mock conference assignment, where students (in groups) both wrote a technical paper solving an assigned problem and (individually) anonymously refereed other groups' papers. In this paper we discuss the details of this assignment and our experiences, and conclude with reflections and future work about similar courses.

cs.CY↗

arXiv2023

Upper Bounds for Covering Arrays of Higher Index

A \emph{covering array} is an $N \times k$ array of elements from a $v$-ary alphabet such that every $N \times t$ subarray contains all $v^t$ tuples from the alphabet of size $t$ at least $λ$ times; this is denoted as $\CA_λ(N; t, k, v)$. Covering arrays have applications in the testing of large-scale complex systems; in systems that are nondeterministic, increasing $λ$ gives greater confidence in the system's correctness. The \emph{covering array number}, $\CAN_λ(t,k,v)$ is the smallest number of rows for which a covering array on the other parameters exists. For general $λ$, only several nontrivial bounds are known, the smallest of which was asymptotically $\log k + λ\log \log k + o(λ)$ when $v, t$ are fixed. Additionally it has been conjectured that the $\log \log k$ term can be removed. First, we affirm the conjecture by deriving an asymptotically optimal bound for $\CAN_λ(t,k,v)$ for general $λ$ and when $v, t$ are constant using the Stein--Lovász--Johnson paradigm. Second, we improve upon the constants of this method using the Lovász local lemma. Third, when $λ=2$, we extend a two-stage paradigm of Sarkar and Colbourn that improves on the general bound and often produces better bounds than even when $λ=1$ of other results. Fourth, we extend this two-stage paradigm further for general $λ$ to obtain an even stronger upper bound, including using graph coloring. And finally, we determine a bound on how large $λ$ can be for when the number of rows is fixed.

math.CO↗

arXiv2021

Distributing hash families with few rows

Column replacement techniques for creating covering arrays rely on the construction of perfect and distributing hash families with few rows, having as many columns as possible for a specified number of symbols. To construct distributing hash families in which the number of rows is less than the strength, we examine a method due to Blackburn and extend it in three ways. First, the method is generalized from homogeneous hash families (in which every row has the same number of symbols) to heterogeneous ones. Second, the extension treats distributing hash families, in which only separation into a prescribed number of parts is required, rather than perfect hash families, in which columns must be completely separated. Third, the requirements on one of the main ingredients are relaxed to permit the use of a large class of distributing hash families, which we call fractal. Constructions for fractal perfect and distributing hash families are given, and applications to the construction of perfect hash families of large strength are developed.

math.CO↗

arXiv2020

Genetic Algorithms for Redundancy in Interaction Testing

It is imperative for testing to determine if the components within large-scale software systems operate functionally. Interaction testing involves designing a suite of tests, which guarantees to detect a fault if one exists among a small number of components interacting together. The cost of this testing is typically modeled by the number of tests, and thus much effort has been taken in reducing this number. Here, we incorporate redundancy into the model, which allows for testing in non-deterministic environments. Existing algorithms for constructing these test suites usually involve one "fast" algorithm for generating most of the tests, and another "slower" algorithm to "complete" the test suite. We employ a genetic algorithm that generalizes these approaches that also incorporates redundancy by increasing the number of algorithms chosen, which we call "stages." By increasing the number of stages, we show that not only can the number of tests be reduced compared to existing techniques, but the computational time in generating them is also greatly reduced.

cs.NE↗

arXiv2018

Counting Subwords and Regular Languages

Let $x$ and $y$ be words. We consider the languages whose words $z$ are those for which the numbers of occurrences of $x$ and $y$, as subwords of $z$, are the same (resp., the number of $x$'s is less than the number of $y$'s, resp., is less than or equal). We give a necessary and sufficient condition on $x$ and $y$ for these languages to be regular, and we show how to check this condition efficiently.

cs.FL↗