Ben Tyler [+]
Associate Professor, Associate Chair
- Modeling Language Design - My involvement in this area started in 2006, where I was tasked with implementing the Rosetta Systems-Level Design Language (SLDL). The language itself was proposed in the late 1990s by people who were into hardware design. Their goal was to create a flexible language that could be used to model different aspects of hardware, but the application areas for this is much wider. What is technically interesting about Rosetta is its ability to modify its own semantics through special reflective “domain” constructs.
Due to the heavyweight nature of the language, implementing full Rosetta is not feasible for a senior project. However, implementing a lightweight version of Rosetta, or preferably a similar type of language that isn’t directly tied to Rosetta, would make for an interesting project. Students would be responsible for aspects of overall language design (what features and syntax?), as well as implementation (parsing, typechecking, executing, etc.) The tricky part is to find a pragmatic way to approach reflection in the language - it needs to be both easy to use and understand, but not so limited as to be useless for real modeling tasks.
Links to get you thinking:
Rosetta SLDL: http://www.rosetta-lang.org
Metaobject Protocol (an approach to reflective OO): http://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Protocol
Aspect-Oriented Programming (related to the idea of reflection, though used for adding features to Java programs): http://eclipse.org/aspectj/
- Design Pattern Languages - Part of my Ph.D work was in this area, where we tried to formally specify design patterns, and then use these specifications to generate monitoring code that could be used for detecting specification violations. The main questions we looked at were:
a) Can we provide precise specifications about what a particular Design Pattern does?
b) Can we statically check or dynamically test if a system properly implements a Design Pattern?
c) How do we tie together a general description of a Design Pattern, and how it is realized in a specific system?
I haven’t looked at this work in a while, but I think it still may bear some fruit (e.g., conference papers.) Some links for consideration:
A related approach is to actually build Design Pattern facilities right into your programming language (http://c2.com/cgi/wiki?PatternLanguagesOfProgramDesign)
Design Patterns could be potentially supported via “add-ons” http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf Jason O. Hallstrom also worked on this problem (we had the same Ph.D advisor): http://people.cs.clemson.edu/~jasonoh/Jasoni_O._Hallstrom/JOH_-_Home.html
Pattern Language Conference-lots of interesting related (and unrelated) work: http://www.hillside.net/plop/2014/
Instructional Tech - We have already gone ahead and “flipped” (https://en.wikipedia.org/wiki/Flipped_classroom) the classroom for CSCI 151 and 152. For this potential project, we want to investigate how we might further improve the classroom experience in our CS courses. I don’t have any particular ideas regarding this right now, but if you have an idea, feel free to try to convince me this would be a worthwhile senior project. One thing that might be interesting is to create some specialized software to help students learn particular concepts for a course.
Intelligent Agent Framework - Okay, here’s the scenario: we have numerous autonomous agents acting in an uncertain and hostile environment, and they must cooperate in some fashion to meet specified goals. Fighting wildfires with UAVs, underwater exploration and/or recovery using UUVs, and battlefield combat and recon operations are all examples that fit the scenario. This project has two components that need to be addressed:
1) We need to develop algorithms for intelligent decision-making in non-ideal situations
2) We need something to help visualize and evaluate how these algorithms work when deployed
For this project, we would need to find a 3D visualization framework for showing what is going on in the scenario environment. We would also need to realistically simulate the entities in the environment, and implement things like physics, dynamics, sensing (observability), constraints on the agents, etc. On the more technical side of things, we would have to develop the decision-making algorithms, which could be based on Neuro-Dynamic Programming (NDP), NFDP, Rule-based systems, machine learning (?), or something else.
Helpful links to people I’ve worked with on this problem:
Nick Hanlon’s M.S. thesis (https://etd.ohiolink.edu/ap/10?0::NO:10:P10_ACCESSION_NUM:ucin1321370261)
Kelly Cohen’s work on SIERRA can be found at the following web link (http://phys.org/news/2014-01-dont-dawn-dronessomeday-life-video.html)
Frameworks listing on Wikipedia:
- Other Potential Projects
Cognitive Architectures (SOAR) (http://sitemaker.umich.edu/soar/home)
Formal Logics for programming languages
Model Checking applications
Testing Object-Oriented Software