In this project, we will design and implement a
software
infrastructure for deploying wireless sensor networks. As an example
application, we will consider the task of deploying a network of
wireless
sensors to monitor temperature in a building (Fig. 1).
Figure
2: Example of
a visualization of a temperature distribution.
Our research group is developing a suite of Cognitive Tutor
Authoring Tools (CTAT), an IDE for the development of intelligent
tutors, software agents that help students learn a complex skill such
as mathematics, computer programming, genetics, and so forth. One can
view these tutors as competent helpers with homework exercises. CTAT
supports the development of two types of tutors: Cognitive Tutors and
so-called "Pseudo Tutors". Cognitive Tutors for high-school math have
been very successful: scientific studies have shown that they
significantly raise students' test scores over more traditional math
instruction and are in routine use in 2000 high schools across the
country. However, they are difficult to build; their "intelligence"
derives from a cognitive model of student thinking, which requires AI
programming to build. Pseudo Tutors are a more novel development: they
retain many of the advantages of Cognitive Tutors, but are much easier
to build (do not require programming, in fact), although they require
more problem-specific authoring than Cognitive Tutors. A major goal of
the CTAT project is to make both types of tutors more widespread, so
that e-Learning courses don't just have static web pages but also
provide interactive activities for students.
So far, CTAT has been used by over 200 people. We are actively
engaged in expanding the user community. In others words, while CTAT is
research, it is also real-world software. More information can be found
at: http://ctat.pact.cs.cmu.edu.
The CTAT tools are being developed by a programming team with
about 12 members, many of whom have a considerable amount of software
engineering experience in industry and half of whom work full time on
CTAT. New versions of CTAT are being released 3 times a year. We expect
that the software developed for the proposed part of the project,
described below, will be included in the CTAT v. 1.6 release, which
will come out in the spring of 2006.
Java (w/ Swing) or possibly, Flash depending on the team's
experience and preference
We would like the help of a software engineering project team with
the implementation of a new interactive tool within CTAT that will make
it easier to develop Pseudo Tutors. We have a detailed design of the
GUI of this tool and the way it interacts with the user. This design
was produced during the summer by an intern, who did extensive testing
of a paper prototype with users in the target population. The new tool
has some complexity but it is not highly complex and seems in fact just
the right size for the kind of project for one semester for a software
engineering class. It offers a convenient interface for entering
various forms of information that are needed during the authoring of a
Pseudo Tutor. The project would involve a significant amount of GUI
programming but would also require hooking up the new tool with the
rest of the tools. Thus, while this piece of the project is relatively
self-contained, it also interfaces with a larger software development
effort. It thus has many aspects of a real-world software development
project. Please note: so far, only the interaction with the user has
been designed for the new tool (a fairly detailed design document
exists). However, no technical design has been made. One possibility
would be to take a rapid prototyping approach: create a prototype based
on the existing design, do product tests with real users to arrive at a
final design, and, time permitting, implement the final design. So the
end product could be for example a prototype, plus the results from
user tests, plus a new design and perhaps even a new implementation.
Alternatively, the implementation effort could focus on the existing
design, in which case the end product might be a new tool, hooked up
with the existing CTAT tool suite. Other options could be explored also.
Project 2: Cognitive Tutor Web-Based Reengineering
Java
The proposed project is in distributed systems: it requires
choosing a communications protocol and establishing the structure
needed to use it. At the heart of our tools, common to all
tutors, is a tutor-controller program that we call the Behavior
Recorder (BR). Attached to it, we support student interfaces
(tutor-specific programs with which a student interacts directly)
written in Flash, Java and, perhaps soon, Javascript. Currently
our BR is single-user (each user needs his or her own instance)
and communicates via a socket. This project is to provide a
communications protocol that will enable us to change the BR into a
service that could be hosted on a web server and serve multiple
users. A requirement is that the protocol not be limited to a
simple request-response model: the BR may send several responses
to a single student action, and the BR might need to initiate a
transaction without waiting for a student request.
The students need to evaluate the trade-offs in choosing a
protocol. As examples we could consider these choices (the
students could come up with others):
a. use our existing protocol over sockets, but it's not
encrypted and would run afoul of many sites' firewall procedures, and
we'd need monitoring mechanisms (killing off inactive sessions, e.g.)
that web and application server environments already provide;
b. try to design a protocol over HTTP, which is request-response
at bottom but has features (the 206 "partial content" response, e.g.),
that might permit us to create the kind of communication we want; but
protocol design is fairly difficult, and even if the design is good,
robust implementation is also a challenge;
c. see if SOAP would serve us: this might be the most modern
solution, but many implementations are slow, and it may be hard to
effect bi-directional spontaneity.
If the team wanted to investigate several approaches and create toy
implementations of more than one, that would be very helpful to
us. The application programming interface to the protocol would
be, ideally, not more elaborate than required for a socket (listen,
connect, send, receive). The team would not need extensive
CTAT-specific knowledge: a fine result would be to build a test
harness, independent of our tools, that demonstrates the protocol.
Web Survey Toolkit Projects (#1-3)
Aaron Powers and Sara Kiesler
apowers at cmu
Java
We are developing the Web Survey Toolbox,
http://WebSurveyToolbox.org.
It's a tool for making web surveys for academic experiments (it's
becoming widely used in the HCII for many web experiments). There are
many other tools that do similar things, but they don't do as much and
don't have the flexibility that Web Survey Toolbox does – for example,
you can insert a few lines of JSP code to do things that are not
pre-programmed. It compares favorably to many other tools, including
commercial ones (see
http://websurveytoolbox.org/FeatureTable.html),
especially in the areas that we need for developing complex web surveys
in the HCII.
The project is implemented in Java & JSP (for the webapp), with
a MySQL database. The GUI uses swing. We develop almost exclusively in
Eclipse.
Web Survey Toolbox is open source using a triple license of
MPL/GPL/LGPL.
There are several different places that a team could work on, depending
upon how much they want to get into existing code or stay independent.
We'd be flexible on what project the group would like to do, though we
would like to make most of the UI specifications.
Project Proposal 1: Question Library
We'd like to build a question library into the program. This would be a
list of scales and other previously researched questions that have been
used for previous research. An HCI team has designed the UI and left
behind some specifications for the project, but the implementation has
not been started.
(This requires some work understanding the current code base).
Project Proposal 2: Graphs and statistics for survey results
For usage by the researcher, we'd like to automatically generate useful
graphs and charts for previewing the results of a survey. This project
can be as small or large as it needs to be – it would also be great to
do preliminary statistics on the data.
We've already written stubs for this and have example code, so the
technical challenges are minimal and it requires a minimal
understanding of existing code.
Project Proposal 3: Making a J2ME version of the survey
This might be the most technically interesting project, and the most
independent of the rest of the our code – it could be done
independently. Basically, it would mean writing a J2ME app and database
that would ask questions and save the answers in a format similar to
the existing JSP webapp.
From our perspective, this is the lowest priority of the projects, but
it might be the most doable by a software engineering team – and
there's the benefit of being able to design an architecture from
scratch.
