Computer Science Faculty WorksCopyright (c) 2024 Swarthmore College All rights reserved.
https://works.swarthmore.edu/fac-comp-sci
Recent documents in Computer Science Faculty Worksen-usWed, 07 Feb 2024 09:51:31 PST3600Trying To Do It All In A Single Course: A Surprisingly Good Idea
https://works.swarthmore.edu/fac-comp-sci/116
https://works.swarthmore.edu/fac-comp-sci/116Mon, 26 Jul 2021 13:01:04 PDT
We present the curricular design and learning goals of an upper-level undergraduate course that covers a wide breadth of topics in parallel and distributed computing (PDC), while also providing students with depth of experience and development of problem solving, programming, and analysis skills. We discuss lessons learned from our experiences teaching this course over the past 10 years, and discuss changes and improvements we have made in its offerings, as well as choices and trade-offs we made to achieve a balance, in a single course, between breadth and depth of topic across these two huge fields. Evaluations from students support that our approach works well meeting the goals of exposing students to a broad range of PDC topics, building important PDC thinking and programming skills, and meeting other pedagogical goals of an advance upper-level undergraduate CS course. Although our single course design was created due to constraints common to smaller schools that have fewer faculty resources, smaller curricula, and often fewer required courses for their majors, our experiences with this course lead us to conclude that it is a good approach for an advanced undergraduate course on PDC at any institution.
]]>
Tia NewhallSmartK: Efficient, Scalable, And Winning Parallel MCTS
https://works.swarthmore.edu/fac-comp-sci/117
https://works.swarthmore.edu/fac-comp-sci/117Mon, 26 Jul 2021 13:01:04 PDT
SmartK is our efficient and scalable parallel algorithm for Monte Carlo Tree Search (MCTS), an approximation technique for game searches. MCTS is also used to solve problems as diverse as planning under uncertainty, combinatorial optimization, and high-energy physics. In these problems, the solution search space is significantly large, necessitating parallel solutions. Shared memory parallel approaches do not scale well beyond the size of a single node's RAM. SmartK is a distributed memory parallelization that takes advantage of both inter-node and intra-node parallelism and a large cumulative RAM found in clusters. SmartK's novel selection algorithm combined with its ability to efficiently search the solution space, results in better solutions than other MCTS parallel approaches. Results of an MPI implementation of SmartK for the game of Hex, show SmartK yields a better win percentage than other parallel algorithms, and that its performance scales to larger search spaces and high degrees of parallelism.
]]>
Michael S. Davinroy et al.A CUDA-MPI Hybrid Bitonic Sorting Algorithm For GPU Clusters
https://works.swarthmore.edu/fac-comp-sci/115
https://works.swarthmore.edu/fac-comp-sci/115Mon, 26 Jul 2021 13:01:03 PDT
We present a hybrid CUDA-MPI sorting algorithm that makes use of GPU clusters to sort large data sets. Our algorithm has two phases. In the first phase each node sorts a portion of the data on its GPU using a parallel bitonic sort. In the second phase the sorted subsequences are merged together in parallel using a reduction sorting network implemented in MPI across the cluster nodes. Performance results comparing our sorting algorithm to sequential quick sort yield speed-up values of up to 9.8 for sorting 4GB of data on a 32 node GPU cluster. We anticipate even better speed-up values using our algorithm on larger data sets and larger sized clusters.
]]>
Sam T. White , '14 et al.Deep Learning In The Classroom
https://works.swarthmore.edu/fac-comp-sci/110
https://works.swarthmore.edu/fac-comp-sci/110Mon, 26 Jul 2021 13:01:00 PDT
This workshop is a hands-on exploration of Deep Learning techniques and topics for use in the classrooms of Computer Science and related fields. Deep Learning denotes the latest in a series of advances in neural network training algorithms and hardware that allow Artificial Neural Networks (ANNs) to learn quickly and effectively, even with many, stacked layers. These types of networks can be applied to almost any learning problem, such as driving a car, describing images, controlling a robot, or understanding language. This workshop will start with the mathematical and algorithmic foundations of Deep Learning, and introduce an accessible Python-based library, called "conx," which is based on the Keras library and was developed by the workshop instructors. The workshop will demonstrate ideas through animation and visualizations, examine the path to advanced topics, and explore ideas for incorporating Deep Learning topics into the classroom. The workshop is designed to allow participants to gain a foothold with these complex topics, and to help them develop their own materials for teaching. Workshop materials will be made freely available before the workshop as Jupyter notebooks.
]]>
D. S. Blank et al.Advanced Robotics Projects For Undergraduate Students
https://works.swarthmore.edu/fac-comp-sci/114
https://works.swarthmore.edu/fac-comp-sci/114Mon, 14 Jun 2021 15:21:48 PDT
The benefits to using robots in the artificial intelligence and robotics classrooms are now fairly well established. However, most projects demonstrated so far are fairly simple. In this paper we explore advanced robotics projects that have been (or could be) successfully implemented by undergraduate students in a one-semester or two-semester course. We explore what makes a good undergraduate advanced project, why such advanced projects are now possible, give example projects, and discuss the benefits of such projects.
]]>
D. S. Blank et al.A Robot Laboratory For Teaching Artificial Intelligence
https://works.swarthmore.edu/fac-comp-sci/113
https://works.swarthmore.edu/fac-comp-sci/113Mon, 14 Jun 2021 15:21:47 PDT
There is a growing consensus among computer science faculty that it is quite difficult to teach the introductory course on Artificial Intelligence well [4, 6]. In part this is because AI lacks a unified methodology, overlaps with many other disciplines, and involves a wide range of skills from very applied to quite formal. In the funded project described here we have addressed these problems by: Offering a unifying theme that draws together the disparate topics of AI; Focusing the course syllabus on the role AI plays in the core computer science curriculum; and Motivating the students to learn by using concrete, hands-on laboratory exercises. Our approach is to conceive of topics in AI as robotics tasks. In the laboratory, students build their own robots and program them to accomplish the tasks. By constructing a physical entity in conjunction with the code to control it, students have a unique opportunity to directly tackle many central issues of computer science including the interaction between hardware and software, space complexity in terms of the memory limitations of the robot's controller, and time complexity in terms of the speed of the robot's action decisions. More importantly, the robot theme provides a strong incentive towards learning because students want to see their inventions succeed. This robot-centered approach is an extension of the agent-centered approach adopted by Russell and Norvig in their recent text book [11]. Taking the agent perspective, the problem of AI is seen as describing and building agents that receive perceptions as input and then output appropriate actions based on them. As a result the study of AI centers around how best to implement this mapping from perceptions to actions. The robot perspective takes this approach one step further; rather than studying software agents in a simulated environment, we embed physical agents in the real world. This adds a dimension of complexity as well as excitement to the AI course. The complexity has to do with additional demands of learning robot building techniques but can be overcome by the introduction of kits that are easy to assemble. Additionally, they are lightweight, inexpensive to maintain, programmable through the standard interfaces provided on most computers, and yet, offer sufficient extensibility to create and experiment with a wide range of agent behaviors. At the same time, using robots also leads the students to an important conclusion about scalability: the real world is very different from a simulated world, which has been a long standing criticism of many well-known AI techniques. We proposed a plan to develop identical robot building laboratories at both Bryn Mawr and Swarthmore Colleges that would allow us to integrate the construction of robots into our introductory AI courses. Furthermore, we hoped that these laboratories would encourage our undergraduate students to pursue honors theses and research projects dealing with the building of physical agents.
]]>
D. Kumar et al.A Situated Vacuuming Robot
https://works.swarthmore.edu/fac-comp-sci/112
https://works.swarthmore.edu/fac-comp-sci/112Mon, 14 Jun 2021 15:21:45 PDT
We undertook this project as an opportunity to explore design ideals of the embodied approach. At our disposal was a Pioneer robot and its Saphira software (ActivMedia 1996). Similar to subsumption architecture (Brooks 1986), the Saphira software tackles the dilemma of how to implement layered control design within a system which is inherently centralized. Brooks saw each layer as a simple and almost independent computational entity and, likewise, Saphira allows us to create a hierarchy of behaviors that each have the capacity to function simultaneously and yet asynchronously. Just as Brooks proposed a means by which one level can subsume a lower level by inhibiting its output, so behaviors can each be assigned a priority.
]]>
Dave J. Bruemmer , '98 et al.Python Robotics: An Environment For Exploring Robotics Beyond LEGOs
https://works.swarthmore.edu/fac-comp-sci/111
https://works.swarthmore.edu/fac-comp-sci/111Mon, 14 Jun 2021 15:21:44 PDT
This paper describes Pyro, a robotics programming environment designed to allow inexperienced undergraduates to explore topics in advanced robotics. Pyro, which stands for Python Robotics, runs on a number of advanced robotics platforms. In addition, programs in Pyro can abstract away low-level details such that individual programs can work unchanged across very different robotics hardware. Results of using Pyro in an undergraduate course are discussed.
]]>
D. S. Blank et al.Laboratories In The Computer Science Curriculum
https://works.swarthmore.edu/fac-comp-sci/109
https://works.swarthmore.edu/fac-comp-sci/109Mon, 14 Jun 2021 15:21:43 PDT
From the beginning, the discipline of computer science has been a laboratory science. In this regard, it stands alongside biology, chemistry, geology, and physics, where students and practitioners formulate conjectures and then design and carry out experiments to study the validity of those conjectures. The laboratory is an integral component of both education and practice in these sciences. In computer science, the laboratory component has been less formal, and most laboratory work has been performed in computer centers, sharing the resources with those who use computers as tools in other disciplines. This arrangement has been unsatisfactory for a number of reasons. It is, therefore, appropriate and timely to consider the nature and relevance of the laboratory session in the computer science curriculum. This report, which is based on deliberations of the Liberal Arts Computer Science Consortium, is a follow‐up to the model curriculum (Gibbs & Tucker, 1986) and considers the role of the computer science laboratory in undergraduate computer science education. This report begins with a description of the laboratory component of computer science. The functional components of the laboratories will then be identified and translated into facilities required.
]]>
J. Parker et al.Incorporating Parallel And Distributed Computing Across A Liberal Arts Computer Science Curriculum
https://works.swarthmore.edu/fac-comp-sci/108
https://works.swarthmore.edu/fac-comp-sci/108Mon, 14 Jun 2021 15:21:42 PDTTia Newhall et al.Optimal Separation And Strong Direct Sum For Randomized Query Complexity
https://works.swarthmore.edu/fac-comp-sci/107
https://works.swarthmore.edu/fac-comp-sci/107Mon, 14 Jun 2021 15:21:41 PDT
We establish two results regarding the query complexity of bounded-error randomized algorithms. Bounded-error separation theorem. There exists a total function f : {0,1}^n -> {0,1} whose epsilon-error randomized query complexity satisfies overline{R}_epsilon(f) = Omega(R(f) * log 1/epsilon). Strong direct sum theorem. For every function f and every k >= 2, the randomized query complexity of computing k instances of f simultaneously satisfies overline{R}_epsilon(f^k) = Theta(k * overline{R}_{epsilon/k}(f)). As a consequence of our two main results, we obtain an optimal superlinear direct-sum-type theorem for randomized query complexity: there exists a function f for which R(f^k) = Theta(k log k * R(f)). This answers an open question of Drucker (2012). Combining this result with the query-to-communication complexity lifting theorem of Göös, Pitassi, and Watson (2017), this also shows that there is a total function whose public-coin randomized communication complexity satisfies R^{cc}(f^k) = Theta(k log k * R^{cc}(f)), answering a question of Feder, Kushilevitz, Naor, and Nisan (1995).
]]>
E. Blais et al.Adapt Or Die: Polynomial Lower Bounds For Non-Adaptive Dynamic Data Structures
https://works.swarthmore.edu/fac-comp-sci/106
https://works.swarthmore.edu/fac-comp-sci/106Mon, 14 Jun 2021 15:21:39 PDT
In this paper, we study the role non-adaptivity plays in maintaining dynamic data structures. Roughly speaking, a data structure is non-adaptive if the memory locations it reads and/or writes when processing a query or update depend only on the query or update and not on the contents of previously read cells. We study such non-adaptive data structures in the cell probe model. The cell probe model is one of the least restrictive lower bound models and in particular, cell probe lower bounds apply to data structures developed in the popular word-RAM model. Unfortunately, this generality comes at a high cost: the highest lower bound proved for any data structure problem is only polylogarithmic (if allowed adaptivity). Our main result is to demonstrate that one can in fact obtain polynomial cell probe lower bounds for non-adaptive data structures. To shed more light on the seemingly inherent polylogarithmic lower bound barrier, we study several different notions of non-adaptivity and identify key properties that must be dealt with if we are to prove polynomial lower bounds without restrictions on the data structures. Finally, our results also unveil an interesting connection between data structures and depth-2 circuits. This allows us to translate conjectured hard data structure problems into good candidates for high circuit lower bounds; in particular, in the area of linear circuits for linear operators. Building on lower bound proofs for data structures in slightly more restrictive models, we also present a number of properties of linear operators which we believe are worth investigating in the realm of circuit lower bounds.
]]>
Joshua Brody et al.Non-Adaptive Data Structures For Predecessor Search
https://works.swarthmore.edu/fac-comp-sci/105
https://works.swarthmore.edu/fac-comp-sci/105Mon, 14 Jun 2021 15:21:38 PDT
In this work, we continue the examination of the role non-adaptivity plays in maintaining dynamic data structures, initiated by Brody and Larsen. We consider non-adaptive data structures for predecessor search in the w-bit cell probe model. In this problem, the goal is to dynamically maintain a subset T of up to n elements from {1, ..., m}, while supporting insertions, deletions, and a predecessor query Pred(x), which returns the largest element in T that is less than or equal to x. Predecessor search is one of the most well-studied data structure problems. For this problem, using non-adaptivity comes at a steep price. We provide exponential cell probe complexity separations between (i) adaptive and non-adaptive data structures and (ii) non-adaptive and memoryless data structures for predecessor search. A classic data structure of van Emde Boas solves dynamic predecessor search in log(log(m)) probes; this data structure is adaptive. For dynamic data structures which make non-adaptive updates, we show the cell probe complexity is O(log(m)/log(w/log(m))). We also give a nearly-matching Omega(log(m)/log(w)) lower bound. We also give an m/w lower bound for memoryless data structures. Our lower bound technique is tailored to non-adaptive (as opposed to memoryless) updates and might be of independent interest.
]]>
Joseph W. Boninger , '16 et al.Position-Based Cryptography And Multiparty Communication Complexity
https://works.swarthmore.edu/fac-comp-sci/104
https://works.swarthmore.edu/fac-comp-sci/104Mon, 14 Jun 2021 15:21:37 PDT
Position based cryptography (PBC), proposed in the seminal work of Chandran, Goyal, Moriarty, and Ostrovsky (SIAM J. Computing, 2014), aims at constructing cryptographic schemes in which the identity of the user is his geographic position. Chandran et al. construct PBC schemes for secure positioning and position-based key agreement in the bounded-storage model (Maurer, J. Cryptology, 1992). Apart from bounded memory, their security proofs need a strong additional restriction on the power of the adversary: he cannot compute joint functions of his inputs. Removing this assumption is left as an open problem. We show that an answer to this question would resolve a long standing open problem in multiparty communication complexity: finding a function that is hard to compute with low communication complexity in the simultaneous message model, but easy to compute in the fully adaptive model. On a more positive side: we also show some implications in the other direction, i.e.: we prove that lower bounds on the communication complexity of certain multiparty problems imply existence of PBC primitives. Using this result we then show two attractive ways to “bypass” our hardness result: the first uses the random oracle model, the second weakens the locality requirement in the bounded-storage model to online computability. The random oracle construction is arguably one of the simplest proposed so far in this area. Our results indicate that constructing improved provably secure protocols for PBC requires a better understanding of multiparty communication complexity. This is yet another example where negative results in one area (in our case: lower bounds in multiparty communication complexity) can be used to construct secure cryptographic schemes.
]]>
Joshua Brody et al.BDSI: A Validated Concept Inventory For Basic Data Structures
https://works.swarthmore.edu/fac-comp-sci/103
https://works.swarthmore.edu/fac-comp-sci/103Tue, 28 Jan 2020 10:56:36 PST
A Concept Inventory (CI) is a validated assessment to measure student conceptual understanding of a particular topic. This work presents a CI for Basic Data Structures (BDSI) and the process by which the CI was designed and validated. We discuss: 1) the collection of faculty opinions from diverse institutions on what belongs on the instrument, 2) a series of interviews with students to identify their conceptions and misconceptions of the content, 3) an iterative design process of developing draft questions, conducting interviews with students to ensure the questions on the instrument are interpreted properly, and collecting faculty feedback on the questions themselves, and 4) a statistical evaluation of final versions of the instrument to ensure its internal validity. We also provide initial results from pilot runs of the CI.
]]>
L. Porter et al.ParaVis: A Library For Visualizing And Debugging Parallel Applications
https://works.swarthmore.edu/fac-comp-sci/102
https://works.swarthmore.edu/fac-comp-sci/102Tue, 28 Jan 2020 10:56:33 PST
This paper presents ParaVis, a visualization library designed to aid programmers' understanding of their parallel programs and to help them identify bugs with parallelization. ParaVis is particularly targeted for programmers who are first learning parallel programming or learning a new parallel language. It provides easy-to-use C and C++ interfaces to create 2D animations of parallel computation that help programmers understand parallel data decomposition patterns. These visualizations are also helpful in illustrating errors in parallel programs. Additionally, because students often find visualization fun, the use of our library often results in students developing interesting extensions to problems, thus promoting a deeper understanding and richer experience with parallel computing. Currently we provide support and sample implementations for pthreads, OpenMP, CUDA, and sequential applications. To test its effectiveness for parallel computing education, we deployed ParaVis for lab assignments in both intermediate and upper level courses. We present example applications, and evaluate the use of the library across our undergraduate CS curriculum.
]]>
Andrew Danner et al.Optimal Separation And Strong Direct Sum For Randomized Query Complexity
https://works.swarthmore.edu/fac-comp-sci/101
https://works.swarthmore.edu/fac-comp-sci/101Tue, 28 Jan 2020 10:56:30 PST
We establish two results regarding the query complexity of bounded-error randomized algorithms. Bounded-error separation theorem. There exists a total function f : {0,1}^n -> {0,1} whose epsilon-error randomized query complexity satisfies overline{R}_epsilon(f) = Omega(R(f) * log 1/epsilon). Strong direct sum theorem. For every function f and every k >= 2, the randomized query complexity of computing k instances of f simultaneously satisfies overline{R}_epsilon(f^k) = Theta(k * overline{R}_{epsilon/k}(f)). As a consequence of our two main results, we obtain an optimal superlinear direct-sum-type theorem for randomized query complexity: there exists a function f for which R(f^k) = Theta(k log k * R(f)). This answers an open question of Drucker (2012). Combining this result with the query-to-communication complexity lifting theorem of Göös, Pitassi, and Watson (2017), this also shows that there is a total function whose public-coin randomized communication complexity satisfies R^{cc}(f^k) = Theta(k log k * R^{cc}(f)), answering a question of Feder, Kushilevitz, Naor, and Nisan (1995).
]]>
E. Blais et al.Non-Adaptive Data Structure Bounds For Dynamic Predecessor Search
https://works.swarthmore.edu/fac-comp-sci/99
https://works.swarthmore.edu/fac-comp-sci/99Thu, 09 Nov 2017 10:01:59 PST
In this work, we continue the examination of the role non-adaptivity} plays in maintaining dynamic data structures, initiated by Brody and Larsen [BL15].. We consider nonadaptive data structures for predecessor search in the w-bit cell probe model. Predecessor search is one of the most well-studied data structure problems. For this problem, using non-adaptivity comes at a steep price. We provide exponential cell probe complexity separations between (i) adaptive and non-adaptive data structures and (ii) non-adaptive and memoryless data structures for predecessor search.
]]>
Joseph W. Boninger , '16 et al.Dependent Random Graphs And Multi-Party Pointer Jumping
https://works.swarthmore.edu/fac-comp-sci/98
https://works.swarthmore.edu/fac-comp-sci/98Thu, 09 Nov 2017 10:01:55 PST
We initiate a study of a relaxed version of the standard Erdos-Renyi random graph model, where each edge may depend on a few other edges. We call such graphs "dependent random graphs". Our main result in this direction is a thorough understanding of the clique number of dependent random graphs. We also obtain bounds for the chromatic number. Surprisingly, many of the standard properties of random graphs also hold in this relaxed setting. We show that with high probability, a dependent random graph will contain a clique of size ((1-o(1))log(n))/log(1/p), and the chromatic number will be at most (nlog(1/(1-p)))/log(n). We expect these results to be of independent interest. As an application and second main result, we give a new communication protocol for the k-player Multi-Party Pointer Jumping problem (MPJk) in the number-on-the-forehead (NOF) model. Multi-Party Pointer Jumping is one of the canonical NOF communication problems, yet even for three players, its communication complexity is not well understood. Our protocol for MPJ3 costs O((n * log(log(n)))/log(n)) communication, improving on a bound from [BrodyChakrabarti08]. We extend our protocol to the non-Boolean pointer jumping problem, achieving an upper bound which is o(n) for any k >= 4 players. This is the first o(n) protocol and improves on a bound of Damm, Jukna, and Sgall, which has stood for almost twenty years.
]]>
Joshua Brody et al.The Information Complexity Of Hamming Distance
https://works.swarthmore.edu/fac-comp-sci/97
https://works.swarthmore.edu/fac-comp-sci/97Thu, 09 Nov 2017 10:01:51 PST
The Hamming distance function Ham_{n,d} returns 1 on all pairs of inputs x and y that differ in at most d coordinates and returns 0 otherwise. We initiate the study of the information complexity of the Hamming distance function. We give a new optimal lower bound for the information complexity of the Ham_{n,d} function in the small-error regime where the protocol is required to err with probability at most epsilon < d/n. We also give a new conditional lower bound for the information complexity of Ham_{n,d} that is optimal in all regimes. These results imply the first new lower bounds on the communication complexity of the Hamming distance function for the shared randomness two-way communication model since Pang and El-Gamal (1986). These results also imply new lower bounds in the areas of property testing and parity decision tree complexity.
]]>
E. Blais et al.