Software Architectures (Spring 2010)
Examination of the fundamental building blocks and patterns for construction of software systems in the context of a sound design process. The course emphasizes the study and development of software systems that can best be understood in terms of sequential software architectures and their architectural and non architectural quality attributes. Class lectures are reinforced by laboratory excerises and projects.
Software Requirements and Specifications (Spring 2010)
In-depth coverage of the early activities of the software development life cycle commonly called software requirements engineering. Topics include requirement elicitation and definition: requirements modeling and analysis: requirements specification; requirements validation; and requirements management. Team projects are emphasized.
Computer Graphics I (Spring 2010)
A study of the hardware and software principles of computer graphics. Topics include an introduction to the basic concepts: 2-D transformations, viewing transformations, display file structure, geometric models, picture structure, interactive and noninteractive techniques, raster graphics fundamentals, 3-D fundamentals, graphics packages and graphics systems. Students will use and develop a graphics software system based on an accepted graphics standard. Programming projects are required.
Native Application Development for iPhone (Spring 2010)
Current topics and advances in applications of computer technology for undergraduate students.
Industrial Organization (Spring 2010)
The study of the structure, conduct and performance of contemporary American industry. Involves the application of the tools of microeconomic analysis and empirical evidence to aid in understanding the behavior of modern industry. In addition, the course considers the historical determinants of contemporary market structure and the public policy measures designed to preserve a competitive market structure.
Engineering Methods of Software Usability (Fall 2009)
This course introduces quantitive models and techniques of human computer interface analysis, design and evaluation, which are relevant to the Software Engineering approach of software development. Contemporary Human Computer Interaction (HCI) techniques are surveyed, with a focus on when and where they are applicable in the software development process. Students will deliver usable software systems derived from an engineering approach to the application of scientific theory and modeling. Other topics may include: usability evaluation planning, methods of evaluation, data analysis, social and ethical impacts of usability, economic justification, prototyping and tools.
Principles of Distributed Software Systems (Fall 2009)
Issues and structures common in the construction of distributed software systems. Emphasis is on fundamentals found in systems of this type. Topics include remote object invocation, middle ware technologies, and common architectural and design patterns. Quality factors will be discussed, including responsiveness, throughput, and extensibility. Team projects are done in a studio format to reinforce concepts presented in class
Benefit-Cost Analysis (Fall 2009)
Explores the use and abuse of benefit-cost and related analytical techniques commonly encountered in economic policy making. Many expenditure and regulatory programs of governmental agencies now are routinely evaluated in a benefit-cost or cost-effectiveness framework, and debate about policy decisions increasingly draws upon benefit-cost findings. Yet, application of benefit-cost analysis often attracts much controversy, in part because of disagreements about how to conduct such analysis and about the role that economic efficiency should play in societal decisions. The mechanics, power and limitations of this form of analysis form the primary elements of the course.
Principles of Concurrent Software Systems (Winter 2008-2009)
Issues and structures common in the construction of concurrent software systems. Emphasis is on fundamentals repeated in the design and development of systems with closely coupled systems concurrently executing components. Topics include modeling, synchronization, and coordination techniques and common architectures for concurrent software systems. Other issues include problem decomposition and analysis of deadlock safety, and liveness.
Software Verification and Validation (Winter 2008-2009)
Introduction to a set of principles and techniques that represent the foundation for improving software products. Topics include verification and validation, unit level testing, system level testing, software quality assurance, and software reliability. Team projects are emphasized.
Principles of Macroeconomics (Winter 2008-2009)
Macroeconomics studies aggregate economic behavior. The course begins by presenting the production possibilities model. This is followed by a discussion of basic macroeconomic concepts including inflation, unemployment and economic growth and fluctuations. The next topic is national income accounting which is the measurement of macroeconomic variables. Following this the aggregate supply-aggregate demand frame- work is presented. The latter part of the course focuses on the development of one or more macroeconomic models, a discusson of the role of money in the macroeconomy, and other topics the individual instructor may choose.
Methods Specifications & Design (Fall 2008)
Introduction to the development of mathematical models of software systems, and the application of such models to the analysis of system properties and verification of design and implementation decisions. Topics include a brief review of logic and set theory, the use of formalism such as Z or VDM, the development of models using the formalism and analysis via simulation or proof of a model's properties. The application of other formalisms, such as state machines and regular expressions, is also surveyed.
Principles of Information Systems Design (Fall 2008)
Issues and structures common in the construction of information systems. Emphasis is on fundamentals repeated in most systems of this type. Topics include historical review of methods of organizing and accessing information, high-level modeling techniques, performance and security concerns, implications of storing new data types (e.g., sound, pictures) and new dimensions (e.g., time) on information systems architectures. Team projects are required.
Software Processes and Project Management (Fall 2008)
An introductory course to software process and related software project management issues. Emphasis is on the study, use, evaluation, and improvmement of the software development process. Topics include software development methodologies, software project planning and tracking, change control, software quality assurance, risk management, and software process assessment and improvement.
Engineering of Software Subsystems (Spring 2008)
An introduction to the principles of the foundations of contemporary software design. Topics include software subsystem modeling, design patterns, design tradeoffs, and component-based software development, with a focus on application of these concepts to concrete design problems. The relationship between design and related process issues such as testing, estimation, and maintenance are also discussed.
Intro to Computer Science Theory (Spring 2008)
Introduction to the classical and contemporary theory of computation covering regular, context-free and computable (recursive) languages with finite state machines, pushdown automation and Turing machines. Basic concepts of computability theory and np-theory.
Personal Software Engineering (Winter 2007-2008)
This is a project-based course to enhance individual, technical engineering knowledge and skills as preparation for upper-division team-based coursework. Topics include adapting to new languages, tools and technologies; developing and analyzing models as a prelude to implementation; software construction concepts (proper documentation, implementing to standards, etc.); unit and integration testing; component-level estimation; and software engineering professionalism.
Computer Science 4 (Winter 2007-2008)
A course on design techniques and advanced programming. Topics include the software development life cycle, analysis and design techniques, programming in C++, and implementation strategies for external data techniques. Students will work individually and in small groups on programming assignments, which will be an integral part of the course. UML and C++ programming language will be used.
Software Engineering (Fall 2007)
An introductory course in software engineering, emphasizing the organizational aspects of software development and software design and implementation by individuals and small teams within a process/product framework. Topics include the software life cycle, software design, user interface issues, specification and implementation of components, assessing design quality, design reviews and code inspections, software testing, basic support tools, technical communication and system documentation, and team-based development. A term-long team-based project done in a studio format is used to reinforce concepts presented in class.
Engineering Fundamentals of Computer Systems (Fall 2007)
This course introduces the computer engineering fundamentals upon which current computer systems are based. Discussion of the machine level representation of data, Boolean algebra and simple logic circuits describes the hardware foundations for modern computer systems. An introduction to instruction set design and assembly language provides the student with an understanding of the interface between hardware and software. The course concludes by discussing high-level architectural design and networking emphasizing its effect on program performance.
Discrete Mathematics 2 (Fall 2007)
This course is a continuation of Discrete Mathematics I with applications in computer science. Topics include relations, their closures, equivalence relations, partial orderings, recursively defined sets, countable and uncountable sets, and an introduction to graph theory.
Computer Science 3 (Spring 2007)
This course is the third course in the computer science introductory sequence and builds upon the computer science foundations and design principles presented in Computer Science 1 and Computer Science 2. Students will learn how to use linear data structures, such as stacks, queues, and lists and non-linear data structures, such as trees and graphs, and will also be introduced to the design and analysis of algorithms. Students will learn how to analyze the efficiency of basic sorting, searching, and hashing algorithms, and acquire an understanding of how recursion works. Object-oriented programming will be used to design solutions and implement them as Java programs. Programming assignments - labs and projects are an integral part of the course.
Discrete Mathematics 1 (Spring 2007)
This course is an introduction to discrete mathematics with applications in computer science and mathematics with an emphasis on proof techniques. Sets, functions, the natural numbers, the integers modulo n and simple combinatorics are covered.
Principles of Microeconomics (Spring 2007)
Microeconomics studies the workings of individual markets. That is, it examines the interaction of the demanders of goods and services with the suppliers of those goods and services. It explores how the behavior of consumers (demanders), the behavior of producers (suppliers), and the level of market competition influence market outcomes
Computer Science 2 (Winter 2006-2007)
This course continues the Java-based introduction to basic computer science concepts begun in Computer Science 1. Essentially, this course covers the use of object-oriented programming to design and implement software solutions. Students will learn how to implement a solution to a problem by reusing existing components and creating new components using inheritance. Other topics include; exception handling, files/streams, collections, threads and thread synchronization, graphical user interfaces (GUI's), networking, and event-driven programming. Programming projects - labs and projects are an integral part of the course.
Computer Science 1 (Fall 2006)
The goal of this course is to introduce the student to the science of computing. The student will learn about the basic elements of computing, including problem decomposition, design and implementation of solutions, testing those solutions and integrating pieces of solutions together. Object-oriented technology is used as a means to an end to design solutions and actually implement them in software. Java is the language used; it is an object-oriented programming language that was designed for developing large systems from reusable components. Programming assignments-labs and post-labs are an integral part of the course.