37,525 research outputs found
Recommended from our members
Using the Internet of Things to Teach Good Software Engineering Practice to High School Students
This paper describes a course to introduce high school students
to software engineering in practice using the Internet Of
Things (IoT). IoT devices allow students to get quick, visible
results without watering down technical aspects of
programming and networking. The course has three broad
goals: (1) to make software engineering fun and applicable,
with the aim of recruiting traditionally underrepresented
groups into computing; (2) to make young students begin to
approach problems with a design mindset; and (3) to show
students that computer science, generally, and software
engineering, specifically, is about much more than
programming. The course unfolds in three segments. The first
is a whirlwind introduction to a subset of IoT technologies.
Students complete a specific task (or set of tasks) using each
technology. This segment culminates in a “do-it-yourself”
project, in which the students implement a simple IoT
application using their basic knowledge of the technologies.
The course’s second segment introduces software engineering
practices, again primarily via hands-on practical tutorials. In
the third segment of the course, the students conceive of,
design, and implement a project that uses the technologies
introduced in the first segment, all while being attentive to the
good software engineering practices acquired in the second
segment. In addition to presenting the course curriculum, the
paper also discusses a first offering of the course in a threeweek
summer intensive program in 2017, including
assessments done to evaluate the curriculum.Cockrell School of Engineerin
Functional Baby Talk: Analysis of Code Fragments from Novice Haskell Programmers
What kinds of mistakes are made by novice Haskell developers, as they learn about functional programming? Is it possible to analyze these errors in order to improve the pedagogy of Haskell? In 2016, we delivered a massive open online course which featured an interactive code evaluation environment. We captured and analyzed 161K interactions from learners. We report typical novice developer behavior; for instance, the mean time spent on an interactive tutorial is around eight minutes. Although our environment was restricted, we gain some understanding of Haskell novice errors. Parenthesis mismatches, lexical scoping errors and do block misunderstandings are common. Finally, we make recommendations about how such beginner code evaluation environments might be enhanced
Getting Started with Particle Metropolis-Hastings for Inference in Nonlinear Dynamical Models
This tutorial provides a gentle introduction to the particle
Metropolis-Hastings (PMH) algorithm for parameter inference in nonlinear
state-space models together with a software implementation in the statistical
programming language R. We employ a step-by-step approach to develop an
implementation of the PMH algorithm (and the particle filter within) together
with the reader. This final implementation is also available as the package
pmhtutorial in the CRAN repository. Throughout the tutorial, we provide some
intuition as to how the algorithm operates and discuss some solutions to
problems that might occur in practice. To illustrate the use of PMH, we
consider parameter inference in a linear Gaussian state-space model with
synthetic data and a nonlinear stochastic volatility model with real-world
data.Comment: 41 pages, 7 figures. In press for Journal of Statistical Software.
Source code for R, Python and MATLAB available at:
https://github.com/compops/pmh-tutoria
A tutorial on recursive models for analyzing and predicting path choice behavior
The problem at the heart of this tutorial consists in modeling the path
choice behavior of network users. This problem has been extensively studied in
transportation science, where it is known as the route choice problem. In this
literature, individuals' choice of paths are typically predicted using discrete
choice models. This article is a tutorial on a specific category of discrete
choice models called recursive, and it makes three main contributions: First,
for the purpose of assisting future research on route choice, we provide a
comprehensive background on the problem, linking it to different fields
including inverse optimization and inverse reinforcement learning. Second, we
formally introduce the problem and the recursive modeling idea along with an
overview of existing models, their properties and applications. Third, we
extensively analyze illustrative examples from different angles so that a
novice reader can gain intuition on the problem and the advantages provided by
recursive models in comparison to path-based ones
Advances in the Design and Implementation of a Multi-Tier Architecture in the GIPSY Environment
We present advances in the software engineering design and implementation of
the multi-tier run-time system for the General Intensional Programming System
(GIPSY) by further unifying the distributed technologies used to implement the
Demand Migration Framework (DMF) in order to streamline distributed execution
of hybrid intensional-imperative programs using Java.Comment: 11 pages, 3 figure
Computer-aided verification in mechanism design
In mechanism design, the gold standard solution concepts are dominant
strategy incentive compatibility and Bayesian incentive compatibility. These
solution concepts relieve the (possibly unsophisticated) bidders from the need
to engage in complicated strategizing. While incentive properties are simple to
state, their proofs are specific to the mechanism and can be quite complex.
This raises two concerns. From a practical perspective, checking a complex
proof can be a tedious process, often requiring experts knowledgeable in
mechanism design. Furthermore, from a modeling perspective, if unsophisticated
agents are unconvinced of incentive properties, they may strategize in
unpredictable ways.
To address both concerns, we explore techniques from computer-aided
verification to construct formal proofs of incentive properties. Because formal
proofs can be automatically checked, agents do not need to manually check the
properties, or even understand the proof. To demonstrate, we present the
verification of a sophisticated mechanism: the generic reduction from Bayesian
incentive compatible mechanism design to algorithm design given by Hartline,
Kleinberg, and Malekian. This mechanism presents new challenges for formal
verification, including essential use of randomness from both the execution of
the mechanism and from the prior type distributions. As an immediate
consequence, our work also formalizes Bayesian incentive compatibility for the
entire family of mechanisms derived via this reduction. Finally, as an
intermediate step in our formalization, we provide the first formal
verification of incentive compatibility for the celebrated
Vickrey-Clarke-Groves mechanism
- …