|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
People
The Web Operated Robotic Machine (WORM) project was designed and implemented by
a team of 4 people. Each of the team members works on every aspect of the
project. In addition, each team member was directly responsible for certain
aspects of the project. Below are the names of the 4 team members that were
assigned to the WORM project. Click on any of the names to learn more about
them and their roles on this project. Each team member has included comments
regarding working on this project and an e-mail link in case you would like to
contact them.
Erin Ecker Keith
Evans Andrew
Lamonica Greg
Bartholomew
Project Origins
As a Computer Science (CS) major at Southern Illinois University Edwardsville
(SIUE), each student is expected to complete a senior assessment. The senior
assessment for the CS department consists of 2 classes taken in succession,
CS425-Software Project Development followed by CS499-Senior Project. The WORM
project began as a senior assessment project in the Fall of 2001.
CS425
CS425 is the design phase of the senior assessment. The class was initially
divided into groups of 3-4 people based upon experience and interests. Projects
were then assigned to the groups. Our group was given the task of creating a
web application to allow the public to control a robot recently purchased by
the SIUE School of Engineering. In addition, the group was to use the web
application as a tool to educate the public about robotics and the challenges
of progressing through such a project. In CS425, the team performed significant
research on the problem and then designed a solution.
CS499
The final phase, CS499, is the course where the design was actually
implemented. This course is designed to allow the students to implement the
skills acquired over their educational career. The programming, testing, and
delivery of the project would have to be completed by the end of the semester.
Students are given an extremely flexible schedule so that they can concentrate
on making a successful project.
|
|
|
|
|
|
|
|
Erin Ecker
|
|
Project Responsibilities:
Project Manager: As the project manager, Erin is the leader of the
team. She is responsible for ensuring that the team is progressing according to
schedule. In order to do this, she must know what everyone else in the team is
working on and how close they are to finishing. If problems arise, she is the
person that will attempt to fix the situation. She has the option of getting
others to help in order to finish on time or revising the schedule to make the
timeline more accurate. As a project manager, Erin must report to the upper
management to report on the progress of the team and their current status.
Webmaster: Each senior project team is responsible for maintaining
a web site with information relevant to their project. The web site must
maintain all of the documentation for the project, information about the team
members, progress reports,and presentations, In addition, our team has material
relevant to the research that has been performed with possible end-users of the
site. The web site must be constantly updated with current progress reports and
updated documentation. This web site is the primary means of for the instructor
to evaluate progress. A link to our Senior Project web site can be found here:
Senior Project web site
Documentation Control: Each senior project is responsible for
creating and revising numerous documents. To be specific, the project is
required to maintain documentation on the Problem Description, Requirements,
Project Plan, Design, Ethical Standards, Customer Contract, Coding Standards,
Status Reports, Post Project Retrospective, User Manual, Testing
Specifications, and the Application Code. As you can see, there is a lot of
material which needs to be standardized and organized into a single location.
Erin is responsible for ensuring all of the documents are properly formatted
and organized.
Back
|
|
|
|
|
Keith Evans
|
Project Responsibilities:
Lead Analyst As the lead analyst, Keith has the primary
responsibility of defining the problem to solve. After the initial assignment
of the problem, a more detailed description was needed. The team needed to know
exactly what the client wanted to get from the application. Numerous client
interviews served to define the full scope of the application. Due to the
educational nature of this application, interviews were also performed with
potential customers. Children ranging from 3rd grade through High School were
interviewed to determine the features the application should support. Once the
problem has been fully defined, the team could begin the design process to
determine the best way to go about solving the problem.
Lead Interface Designer: The interface is the part of the
application that the user sees and interacts with. A good design will allow the
application to be easy to use and enjoyable. Keith was primarily responsible
for ensuring the application was self-explanatory and easy to navigate through.
Prototyping sessions with children allowed the team to design the page layout
and navigation so that everything made sense and flowed smoothly. A good design
allows a smooth transition to implementation.
Primary Client Point of Contact: As the person in charge of
defining the problem and designing the appearance of the application, Keith was
the logical choice for the primary point of contact with the client. This
position entails keeping the client up to date with current ideas and plans for
the project. The close communication with the client ensures that the team is
building an application to their exact specifications and that there are no
surprises when the project is completed and turned over to the client. By
allowing Keith to be the primary point of contact, the client had contact with
the team member intricately involved in defining the client needs and the
appearance the application would be taking.
Back
|
|
|
|
Andrew Lamonica
|
|
Project Responsibilities:
Lead Implementation Designer: The design phase of the project is
one of the most critical aspects of a successful project. Without a good
design, the team would spend countless hours writing unnecessary code. As the
lead implementation designer, Andrew had to figure out how the application was
going to work from a programmer's perspective. Without worrying about the
appearance of the application, he was concerned with how communication would
take place and exactly what type of information needed to be sent and stored.
The implementation design entails researching current technologies and
determining the best language to write the code in and the most efficient
formulas for calculations. By the end of the design phase, the application was
laid out like the blueprints of a building. The programmers could go straight
from the design into the coding of the application.
Lead Programmer: As the lead programmer, Andrew is the person
responsible for ensuring all of the underlying code is written. This
application is much more than a typical web page. In order to control the robot
over the Internet, a significant amount of code must be written for
communication, sending commands to the robot and receiving information from the
robot. Andrew is responsible for assigning programming tasks to other group
members. Based on the implementation design, the code is written in small
segments, known as modules. This allows future teams to more easily maintain
the application and make modification. Also, this allows the programmers to
code small segments rather than large applications all at once. Once all of the
modules have been written, Andrew is responsible for ensuring that everything
is incorporated into one large application ready for testing.
Back
|
|
|
|
|
Greg Bartholomew
|
Project Responsibilities:
Lead Tester: As the lead tester, Greg is responsible for ensuring
the application works the way it was designed to work. Every module that is
written and every combination of modules must be tested for accuracy and
reliability. In order to prepare for testing, Greg initially designed a test
plan. This plan included the outline of when, where and how testing would take
place. The team had to have set guidelines to ensure every portion of the code
worked the way it was designed. As an additional task, Greg designed specific
test scenarios. When the team was ready for testing, a guideline would already
be set up with numbers and scenarios to run in order to speed up the testing
process. As the lead tester, Greg performed the majority of actual code
testing. He ran modules of code against the test data and checked the results
and performance against anticipated values. As modules were combined together,
he tested the communication between the modules and the information sent back
and forth. By the time the application was ready for release, Greg had ensured
that the application would perform exactly as designed with the performance
characteristics specified during the design.
Back
|
|
|
|
|