Foundations of Software Engineering
Tuesday and Thursday
11:00 AM - 12:15 PM
What's New (Home)
CSCI 5828 Example Project Proposals
Projects are supposed to be an effort equivalent to a 25-page paper and demonstrate that you've gotten some depth of experience with a software engineering topic. The proposal should describe the particular technique(s) to be used, the problem it will be applied to, and the expected result. I've included several sample proposals from a previous instance of this class below.
I'd be happy to talk to you all about project plans and such. I'd like you to do something in which you're interested and excited.
For my project for CSCI 5828 I will be creating and examining a test suite for the LSI program which was created at US West. The program is written in C and is the basic underpinnings of an information search engine that takes a set of documents and then creates an index so that queries can be made to find documents that pertain to certain topics.
I will devise a testing scheme for this program and then use the ATAC package (developed at Bellcore) to analyze the coverage and overall effectiveness of the tests that I select.
The project will consist of several pages explaining LSI and its uses. Next, I will discuss the testing scheme that I select to test the functionality and performance of the LSI program. I will then discuss ATAC and the coverage measure that it uses to determine the effectiveness of a testing scheme. Lastly, I will show the analysis that ATAC gives of my testing scheme for LSI.
I do not know anything about ATAC at this point, so a good deal of time will be spent familiarizing myself with the product.
For my project, I would like to explore further the algebraic specification technique by doing a more in-depth specification than was done for homework in class. Since algebraic techniques are more suited to specifying data structures, one strong possibility for my project would be to formally specify a subset of the major data structures involved in a current research project of mine. Briefly, the project involves implementing a multimedia browsing system based on the concept of cohesive element paths. The underlying data structure on which presentations to be browsed are based is essentially a directed graph, made up of links and nodes. The authoring tool that we are building provides facilities for constructing a presentation (graph), which includes a number of operations that are performed on the component data structures (nodes, paths, presentations). Specification of the effects of these operations could be the focus of the project. As you suggested, I would also likely learn the Larch specification system available in the department and use it to encode the specification. My final document would most likely include about 10 pages of specification and 15 pages of supporting documentation, give or take 20% or so on each side.
For my final project, I would like to work on incorporating some of the formal software engineering from our class into a project I am working on at work. I don't have much experience in working with Finite State Machines, and I am also extremely interested in learning more about Petri Nets. This project I am working on seems like an excellent fit for learning more about both.
This is an abstract of my project. I am designing and implementing a "UDP connectionless messaging layer" in the form of a set of reusable Visual Basic custom controls, forms, and program files. Basically, others in my company will utilize my messaging layer as an abstraction to easily, generically, and robustly do interprocess communication via both LAN and WAN (via the Internet, of course). Since they will be using Visual Basic for their development, the messaging layer I am working on needs to be abstracted in a way that it hides the compexity of IPC. (However, I will actually be porting the messaging layer to UNIX, since we have unix servers that will be involved in "routing" functions across the WAN).
My final project for your class will, hopefully, only deal with handling the complexities inherent with the actual communications aspects of my project, and not the whole project (e.g. no user interface, no testing, etc.) This way, I hope that I can keep it to a manageable size (at this point, I'll feel lucky if I can do a decent job of fulfilling this scope within about 30 pages of text/diagrams/Petri Nets).
I propose to look at the modifications that would be interesting or necessary to make to a source code specification system, like APP, if it was to operate in a distributed environment, and on a distributed language, like Orca.
I propose to start off with a summary of APP and its current specification, to show what it can currently do and not do. This will be a few pages of text, and probably a couple of example C programs. Judy Stafford has informed me that APP is available on the departmental Alpha's, so that's where I would do this section of the project.
After that, I would discuss a distributed programming language, like Orca or possibly one from DEC, and how the language differs from C in its requirements and such. This section would show some of the features that would be nice to have in an APP like tool when working with a distributed language. It would also show how the current features of APP could be adapted for this environment. This section would be mostly text, with some code comparisons and such between C and Orca.
The third section would be proposed extensions to APP to better handle a distributed language, with its specific demands and requirements. I would attempt to cover these extensions to the APP specification in a fairly rigerious way, showing why they are necessary. This section would include text, some specifications, and code examples showing the use of the new features.
Overall, I see this project as looking into the differences in specifications for a local language, like C, and a distributed one, like Orca. This is important, as distributed computing environments become more and more prevalent.
My personal reasons for doing this project, and what I hope to get out of it, are a better understanding of APP, and other code level tools, and how they would interact with a distributed system. I'm very interested in distributed systems as a whole, and see this as an interesting aspect to study in this class.
I am going to investigate the use of Larch within the context of specifying component Data Structures of an interactive 3d world, that is being developped. In the process of this exploration I hope to learn something about both my DataStructures and about Larch. I would like to be able to say something about Larch at the end of the project, ie. whether it is a useful tool or just a nice abstract idea. The system that I am investigating is implemented in C++, which allows me to use the version of Larch that has been developed for C++.
In the system that I am investigating there are six primary DataStructures: BSP-Tree, Viewer, Cell, MapTree, Portals, and Polygons. All of these DS are C++ classes that contain some functionality as well as data. It is my hope that Larch will enable me to prove some properties about the DSs.
There are two specification languages which use the evolutionary approach to designing a specification language. In this approach, an existing higher level language is extended. The first specification language developed in this manner was Anna which was an extension of Ada. It was developed by David C. Luckham. The second specification language developed in this manner was APP for the programming language C. APP was developed by David Rosenblum.
In this project, I will propose some annotations for C++ which can be applied to the constructs of this language which make the language object-oriented, such as classes, inheritance between classes, templates, etc. Since C++ is an extension of C, I will use APP as a foundation. By this is I mean that, I will borrow the format of the APP specification language to derive new annotations. The syntax and properties for these proposed annotations will be derived from those of APP and Anna. I will also look at studies of the theory of programming specifications for additional information with respect to specifying the semantics of classes and various forms of inheritance.
The final paper will include an overview of what dynamic analysis of logic-based specifications entails. It will include a discussion on Anna and APP. It will also include the syntax for the added annotations and an explanation of how each annotation constrains all sets of observable states of its scope. Furthermore, it will also include examples of how these annotations would be applied to various constructs of C++. Through the use of these examples, the meaning of each type of annotation will be informally described by the properties that are satisfied in the text of the C++ code. Finally, the paper will summarize limitations or problems encountered in designing formal specifications using the evolutionary approach on C++.
© Ken Anderson, 2000.
Last Updated: 8/16/00; 2:45:44 PM