Thomas J. Bannan Chair, 2007 - 2009
Science and Software Engineering
Last modified July 2014
Software should be effective, responsive, efficient and, ideally, maintainable. Software complexity, the breadth of software applications, and the preponderance of legacy systems sustain an interest in software design. How is software structured? What are key interfaces? How can software be extended? What are the costs of a flexible design? Who manages variant behavior? Such questions can be answered with an understanding of software design. The best means to impart the tenets of software design, and the current tools available to do so, are areas of interest.
Efficient memory management
Software applications, such as real-time systems, demand high performance. Embedded applications must run on a constrained footprint. Even applications without specific memory requirements, such as speed or size, should run correctly. Thus, it is critical to understand program memory, and how software design impacts the use of memory. Software developers should recognize the effects of language choice, and evaluate the trade-offs presented by garbage-collected vs. programmer-managed memory. The evaluation of memory usage with respect to software design and programming languages are key areas to explore.
Object-oriented Programming Languages
OOPLs advanced the development of large-scale software systems, software libraries, and extensible code. Many modern OOPLs are actually hybrid languages as they support structured programming as well as OOD (Object-Oriented Design). The utility of an OOPL greatly impacts software design, in terms of programming language support for encapsulation, abstraction, information hiding, polymorphism and maintainability. As many languages incorporate OO features, we can evaluate language support and the consistency with which software can be designed.
The preponderance of legacy systems motivates attention toward restructuring code for longevity -- that is, refactoring. Clean-slate software design is a rarity, often considered a luxury. Hence, we consider software design and the utility of tools with respect to software evolution.
Reclaiming Garbage and Education: Java Memory Leaks
Tracking the Design of Objects: Encapsulation Through Polymorphism
The Maintainability Gap
Assessing the Ripple Effect of Language Choice in CS1
Improving C++ Performance Using Temporaries
The Object-Ownership Model: A Case Study for Inheritance and Operator Overloading
CPSC Search Committee, Chair
CPSC Curriculum Committee
Sullivan Leadership Program Committee
|This is a personal WEB site developed and maintained by an individual and not by Seattle University. The content and link(s) provided on this site do not represent or reflect the view(s) of Seattle University. The individual who authored this site is solely responsible for the site's content. This site and its author are subject to applicable University policies including the Computer Acceptable Use Policy (www.seattleu.edu/policies).|