CS Curricula

Courses tagged with softeng

CSE 360: Introduction to Software Engineering (3) softeng

Software life cycle models; project management, team development environments and methodologies; software architectures; quality assurance and standards; legal, ethical issues. (ASU)

CSE 446: Software Integration and Engineering (3) softeng

Software development using architecture design, composition, workflow, services, data resources, data representations, data management, and development tools. (ASU)

CSE 460: Software Analysis and Design (3) softeng

Object-oriented and structured analysis and design; software architecture and design patterns; component-based development; software safety and reliability. (ASU)

CSE 464: Software Quality Assurance and Testing (3) softeng

Software quality assurance (SQA), software quality metrics, software configuration management, software verification and validation, reviews, inspections, understanding software testing process, functional testing, structural testing, model-based testing, integration, system, and regression testing techniques, software life cycle models and software testing, testing distributed software, bug management, and use of testing tools. (ASU)

COMP 2710: Software Construction (3) softeng

Intensive experience in software construction, to include topics such as testing, debugging, and associated tools; configuration management; low-level file and device I/O; systems and event-driven programming. (Auburn)

COMP 3700: Software Modeling And Design (3) softeng

Current processes, methods, and tools related to modeling and designing software systems. Communication, teamwork, and a design experience are integral course experiences. (Auburn)

COMP 5700: Secure Software Process (3) softeng

Process models of the software life cycle as well as methods and tools for software development with a special emphasis on secure software engineering. (Auburn)

COMP 5710: Software Quality Assurance (3) softeng

Processes, methods, and tools associated with the production of robust, high-quality software. (Auburn)

MINF 3625: Project Management (3) softeng

Project management is the use of a standardized set of documented processes to control projects in an organization. This course addresses the life cycle of a project, the management of the project, how a project scope is written, how the time management is constructed and communicated. (Augusta)

CSCI 4711: Software Engineering (3) softeng

The software development process is examined. Current tools and techniques of software system analysis, design, implementation, and maintenance are presented in conjunction with case studies and team-oriented projects. Topics include process modeling, logic modeling, object-oriented modeling, UML, software metrics, prototyping, and software security. (Augusta)

CSI 3342: Principles of Software Design (3) softeng

An introduction to object-oriented analysis and design. Iterative development; identification of requirements; software development process; UML notation, models and methods; and introduction to design patterns. Software project using an object-oriented language. (Baylor)

CSI 3371: Software Engineering I (3) softeng

Fundamentals of Software Engineering; software development processes, requirements analysis, modular design and implementation of software systems, software testing and evolution. A small project to illustrate and extend concepts from lectures. (Baylor)

CSI 3372: Software Engineering II (3) softeng

An engineering approach to software development emphasizing design patterns and techniques for enterprise application development. Completing software project applying development process. (Baylor)

CSI 3373: Software Quality Assurance and Testing (3) softeng

Quality, how to assure it and how to verify that it exists; the need for a culture of quality; how to avoid errors; inspections and reviews; verification versus validation; testing, verification, and validation techniques; process assurance and product assurance; quality process standards; faults; problem analysis and reporting; and statistical approaches to quality control. (Baylor)

CSI 3374: Software Project Management (3) softeng

Project planning, cost estimation, and scheduling; project management tools; factors influencing productivity and success; productivity metrics; analysis of options and risks; planning for change; management of expectations; release and configuration management; software process standards and process implementation; and software contracts and intellectual property. (Baylor)

CSI 3471: Software Engineering I (4) softeng

Introduction to UML notation; constructing and interpreting use cases; interpreting UML models; introduction to design patterns; introduction to testing; introduction to configuration management; Java as a second language; and implementing a graphical user interface. Laboratory assignments and a small project illustrate and extend concepts from lectures. (Baylor)

CSI 4344: Object-Oriented Development (3) softeng

Object-oriented analysis and design methods. Group software projects. (Baylor)

CS 402: Software & Eng. Project Mgmt (4) softeng

Information is traveling faster and being shared by more individuals than ever before. Although project management has been an established field for many years, managing Software Development and Information Technology Projects requires ideas and information that go beyond standard project management. This course presents an understandable, integrated view of the many concepts skills, tools, and techniques involved in software project management. The Project Management Knowledge areas (from PMI?s PMBOK) are used to guide the student through the concepts of Software Project Management techniques and their application to the management of software and IT projects. Specifically, students will learn how to develop a software development plan including its associated tasks, milestones and deliverables, software project scheduling and how/why to establish relationships among the different tasks. (Binghamton)

CS 442: Design Patterns (4) softeng

Patterns for program design including examples of patterns used in existing software libraries. Exercises in programming with design patterns and communicating designs to other programmers using the language of patterns. Use of an object-oriented programming language to implement patterns and principles for common design problems. Design patterns are applied to problems involving features including concurrency, sockets, streams, reflection, and dynamic proxies. The course also discusses automating software build processes with build tools. (Binghamton)

CS 445: Software Engineering (4) softeng

Software engineering practice applied to the life cycle of software applications and engineering projects. Software project planning and management: risk management, estimation, scheduling, trade studies, CM and SQA. Software development: process model selection, domain analysis, requirements gathering, analysis and design modeling, user interface design, architectural and detailed design, documentation, testing strategies/methods, test plan generation, and reuse. Advanced topics include formal methods and cleanroom software engineering. Requires a major team project. (Binghamton)

ADIT2750: Systems Analysis and Design (4) softeng

In this course, students will learn the concepts of the software development lifecycle. Students will learn the concepts of Agile and Waterfall and associated software tools. Likewise an in-depth discussion of the principles of the Information Technology Infrastructure Library (ITIL) framework will be discussed regarding overall service management. Each topic will be discussed with an overall risk management approach. (Boston)

ADIT2757: Systems Analysis and Design (4) softeng

? (Boston)

ADIT3308: Project Management (4) softeng

Participation in IT projects can happen from a variety of angles; from individual contributor, to project team member, to project manager and executive sponsor. As such, this course will take a 360-degree perspective on project management, incorporating the important peripheral elements that influence the discipline. This course will help students develop practical skills for functioning in a variety of roles on projects, including project manager, while developing an appreciation for the importance of governance and project and portfolio management (PPM) in an IT environment, looking at the concept and the practice of projects from the perspective of participant, practitioner, and executive sponsor. (Boston)

CSCI3356: Software Engineering (3) softeng

This course covers the basic life cycle of software development: requirements, design, implementation, testing, and production release. Students will learn the theory related to software engineering, but they will also learn hands-on how to create their own software. The main evaluation of the course is a team project that will simulate a small real project. The project will be done using the framework Django (Python), the CSS Framework Bootstrap, among other technologies. The project will be worth 50% of the grade, as well as 2 midterms, an exam, and a peer assessment (how your team members evaluate the work you did). (Boston)

CS 411: Software Engineering (4) softeng

Introduction to the construction of reliable software. Topics may include software tools, software testing methodologies, retrofitting, regression testing, structured design and structured programming, software characteristics and quality, complexity, entropy, deadlock, fault tolerance, formal proofs of program correctness, chief program teams, and structured walk-throughs. (BU)

CS 511: Formal Methods 1 (4) softeng

Introduction to formal specification, analysis, and verification of computer system behavior. Topics include formal logical reasoning about computer programs and systems, automated and semi-automated verification, and algorithmic methodologies for ascertaining that a software system satisfies its formally specified properties. (BU)

CS 519: Spark! Software Engineering X-Lab Practicum (4) softeng

Consent provided upon successful completion of pass/fail diagnostic test that assesses student readiness to take the course. This course offers students in computing disciplines the opportunity to apply their programming and system development skills by working on real-world projects provided from partnering organizations within and outside of BU, which are curated by Spark! The course offers a range of project options where students can improve their technical skills, while also gaining the soft skills necessary to deliver projects aligned to the partner's goals. These include teamwork and communications skills and software development processes. (BU)

COSI 103a: Fundamentals of Software Engineering (4) softeng

In this course, you will learn (and practice) the design and construction of large bodies of software using modern software engineering practices, including object oriented design, test driven development, working data, and project management. You will be challenged to solve different kinds of problems, using different approaches and different tools. The course also aims to teach the basic and expected knowledge and practice within industry for entry level developers. Usually offered every year. (Brandeis)

COSI 105b: Software Engineering for Scalability (4) softeng

Covers some of the 'big ideas' that come in to play when building large, complex, and highly scaled software systems. We will look at both research and practice scaling architecture and software design. How do you design and architect large scale web based systems? What are the classic algorithms and patterns used to achieve massive scale? We will look at caching, database partitioning, queueing, messaging and more. And we apply this learning working in teams of students to design and implement their own version of the Twitter backend from the ground up, and then stress test and measure it's scalability using real world tools and technologies. Usually offered every year. (Brandeis)

CSCI 0320: Introduction to Software Engineering (1) softeng

Focuses on designing, building, testing, and maintaining systems collaboratively. It covers programming techniques (using Java and TypeScript with various frameworks), object-oriented design, advanced testing (e.g., fuzz testing), debugging approaches, and tools such as source control systems. The course concludes with a major group project that students gather requirements for, then design and implement themselves. (Brown)

CSCI 1340: Introduction to Software Engineering (1) softeng

CSCI 1340 focuses on designing, building, testing, and maintaining systems collaboratively. It covers programming techniques (using Java and TypeScript with various frameworks), object-oriented design, advanced testing (e.g., fuzz testing), debugging approaches, and tools such as source control systems. The course concludes with a major group project that students gather requirements for, then design and implement themselves. Note: CSCI 1340 is for Master's students only (they may not register for 0320). It is identical to 0320 but with the addition of supplemental work for each sprint. (Brown)

CS 3: Introduction to Software Design (9) softeng

CS 3 is a practical introduction to designing large programs in a low-level language. Heavy emphasis is placed on documentation, testing, and software architecture. Students will work in teams in two 5-week long projects. In the first half of the course, teams will focus on testing and extensibility. In the second half of the course, teams will use POSIX APIs, as well as their own code from the first five weeks, to develop a large software deliverable. Software engineering topics covered include code reviews, testing and testability, code readability, API design, refactoring, and documentation. (Caltech)

CS 130: Software Engineering (33) softeng

This course presents a survey of software engineering principles relevant to all aspects of the software development lifecycle. Students will examine industry best practices in the areas of software specification, development, project management, testing, and release management, including a review of the relevant research literature. Assignments give students the opportunity to explore these topics in depth. Programming assignments use Python and Git, and students should be familiar with Python at a CS 1 level, and Git at a CS 2CS 3 level, before taking the course. (Caltech)

CS 257: Software Design (6) softeng

It’s easy to write a mediocre computer program, and lots of people do it. Good programs are quite a bit harder to write, and are correspondingly less common. In this course, we will study techniques, tools, and habits that will improve your chances of writing good software. While working on several medium-sized programming projects, we will investigate code construction techniques, debugging and profiling tools, testing methodologies, UML, principles of object-oriented design, design patterns, and user interface design. (Carleton)

CS 347: Advanced Software Design (6) softeng

This course helps students to strengthen their ability to design modular, extensible and maintainable software. The focus of the course is on the design of modern cloud applications. Students will learn how to decompose complex applications into a set of back-end services, develop and debug these services, and deploy them in the cloud. This class is structured around a large project that will be extended over the course of the term. (Carleton)

15-214: Principles of Software Construction: Objects, Design, and Concurrency (12) softeng

Software engineers today are less likely to design data structures and algorithms from scratch and more likely to build systems from library and framework components. In this course, students engage with concepts related to the construction of software systems at scale, building on their understanding of the basic building blocks of data structures, algorithms, program structures, and computer structures. The course covers technical topics in four areas: (1) concepts of design for complex systems, (2) object oriented programming, (3) static and dynamic analysis for programs, and (4) concurrent and distributed software. Student assignments involve engagement with complex software such as distributed massively multi-player game systems and frameworks for graphical user interaction. (CMU)

15-313: Foundations of Software Engineering (12) softeng

Students gain exposure to the fundamentals of modern software engineering. This includes both core CS technical knowledge and the means by which this knowledge can be applied in the practical engineering of complex software. Topics related to software artifacts include design models, patterns, coding, static and dynamic analysis, testing and inspection, measurement, and software architecture and frameworks. Topics related to software process include modeling, requirements engineering, process models and evaluation, team development, and supply chain issues including outsourcing and open source. This course has a strong technical focus, and will include both written and programming assignments. Students will get experience with modern software engineering tools. (CMU)

17-313: Foundations of Software Engineering (12) softeng

Students gain exposure to the fundamental principles of software engineering. This includes both core CS technical knowledge and the means by which this knowledge can be applied in the practical engineering of complex software in real-world settings. Topics related to software artifacts include coding, software architecture, measurement, and quality assurance of various qualities (e.g., robustness, security, performance, maintainability) with static and dynamic analysis, testing, code review, and inspection. Topics related to software process include requirements engineering, process models and evaluation, personal and team development, and supply chain issues including outsourcing and open source. This course has a strong technical focus, a strong focus on developing team skills, and will include both written and programming assignments. Students will get experience with the latest software engineering tools and practices. (CMU)

15-413: SEE 17-413 Software Engineering Practicum (12) softeng

This course is a project-based course in which students conduct a semester-long project for a real client in small teams. The project defines real world needs for the client in their company. This is not a lecture-based course; after the first few weeks the course consists primarily of weekly team meetings with the course instructors, with teams making regular presentations on their software development process. Teams will give presentations and deliver documents on topics such as: risk management project planning requirements architecture detailed design quality assurance final product presentations reflections on the experience Evaluation will be based on the in-class presentations, process and project documentation, how well the teams follow software engineering (SE) practices, and the client's satisfaction with the product. Individual grades will be influenced by peer reviews, individual reflection documents, mentor impressions, and presentation performance. Students will leave the course with a firsthand understanding of the software engineering realities that drive SE practices, will have concrete experience with these practices, and will have engaged in active reflection on this experience. They will have teamwork, process, and product skills to support immediate competency in a software engineering organization, along with a deeper understanding that prepares them to evaluate the new processes and techniques they will encounter in the workplace. (CMU)

CSDS 293: Software Craftsmanship (4) softeng

A course to improve programming skills, software quality, and the software development process. Software design; Version control; Control issues and routines; Pseudo-code programming process and developer testing; Defensive programming; Classes; Debugging; Self-documenting code; Refactoring. (Case)

CSDS 293N: Software Craftsmanship (4) softeng

CSDS 393: Software Engineering (3) softeng

Topics: Introduction to software engineering; software lifecycle models; development team organization and project management; requirements analysis and specification techniques; software design techniques; programming practices; software validation techniques; software maintenance practices; software engineering ethics. Undergraduates work in teams to complete a significant software development project. Graduate students are required to complete a research project. (Case)

CSDS 393N: Software Engineering (3) softeng

CSDS 493: Software Engineering (3) softeng

CP274: Software Design (1) softeng

Fundamentals of design and implementation of 'real world' software. Topics include testing, databases, user interface design, collaborative development practices, and software specifications. (Colorado)

CP499: Team Software Project (1) softeng

Students work in teams to design, document, implement, and test a software project. Required for majors in computer science. (Colorado)

COMS W3102: Development Technology (12) softeng

Introduction to software development tools and environments. Each section devoted to a specific tool or environment. One-point sections meet for two hours each week for half a semester, and two point sections include an additional two-hour lab (Columbia)

COMS W3107: Clean Object-Oriented Design (3) softeng

A course in designing, documenting, coding, and testing robust computer software, according to object-oriented design patterns and clean coding practices. Taught in Java.Object-oriented design principles include: use cases; CRC; UML; javadoc; patterns (adapter, builder, command, composite, decorator, facade, factory, iterator, lazy evaluation, observer, singleton, strategy, template, visitor); design by contract; loop invariants; interfaces and inheritance hierarchies; anonymous classes and null objects; graphical widgets; events and listeners; Java's Object class; generic types; reflection; timers, threads, and locks (Columbia)

COMS W4137: From Algorithmic Thinking to Development (3) softeng

Algorithmic problem-solving and coding skills needed to devise solutions to interview questions for software engineering positions. Solutions are implemented in Python, Java, C, and C . Approaches include brute-force, hashing, sorting, transform-and-conquer, greedy, and dynamic programming. Focus on experimentation and team work (Columbia)

COMS W4152: Engineering Software-as-a-Service (3) softeng

Modern software engineering concepts and practices including topics such as Software-as-a-Service, Service-oriented Architecture, Agile Development, Behavior-driven Development, Ruby on Rails, and Dev/ops (Columbia)

COMS W4153: Cloud Computing (3) softeng

Software engineering skills necessary for developing cloud computing and software-as-a-service applications, covering topics such as service-oriented architectures, message-driven applications, and platform integration. Includes theoretical study, practical application, and collaborative project work (Columbia)

COMS W4156: Advanced Software Engineering (3) softeng

Software lifecycle using frameworks, libraries and services. Major emphasis on software testing. Centers on a team project (Columbia)

COMS W4444: Programming & Problem Solving (3) softeng

Hands-on introduction to solving open-ended computational problems. Emphasis on creativity, cooperation, and collaboration. Projects spanning a variety of areas within computer science, typically requiring the development of computer programs. Generalization of solutions to broader problems, and specialization of complex problems to make them manageable. Team-oriented projects, student presentations, and in-class participation required (Columbia)

CS 5150: Software Engineering (4) softeng

Introduction to the practical problems of specifying, designing, building, testing, and delivering reliable software systems. Special topics include professionalism, project management, and the legal framework for software development. As a central part of the course, student teams carry out projects for real clients, using concepts of agile software development. Each project includes all aspects of software development from a feasibility study to final delivery. (Cornell)

COSC 50: Software Design and Implementation (1) softeng

Techniques for building large, reliable, maintainable, and understandable software systems. Topics include UNIX tools and filters, programming in C, software testing, debugging, and teamwork in software development. Concepts are reinforced through a small number of medium-scale programs and one team programming project. (Dartmouth)

CS 3300: Introduction to Software Engineering (3) softeng

Team-based project class to introduce and apply software engineering principles and practices. (Georgia Tech)

COMPSCI 1070: Systems Development for Computational Science (4) softeng

This is a project-based course emphasizing designing, building, testing, maintaining, and modifying software for scientific computing and data sciences. The class is focusing on a thorough introduction of the Python programming language with discussion of core concepts in object-oriented programming as well as essential data structures useful in most programming tasks. Students will work in groups on a semester long project. Students will further learn how to work with SQL databases and how to integrate them in Python using SQLite3 and Pandas. After completion of this course, students will be able to adapt basic tools and techniques to design complex software systems aimed at solving computational and data processing problems in academic and industrial environments. (Harvard)

COMPSCI 1960: Designing K-12 Computer Science Learning Experiences (4) softeng

From computational thinking to workforce arguments, there is considerable interest in and excitement about including computer science education for all K–12 students. Yet, unlike other disciplines with a much longer history in formal schooling, the interest in computer science education is not yet supported by commensurate attention to research and teacher practice. In this course, we will examine the state of K–12 computing education: questioning its value, examining its history, and imagining and contributing to its potential. The course will be organized as both a reading group and a lab, building a community of people who are committed to K–12 CS education. Each week you will read classic and current research, and write accompanying memos to document your evolving understandings of the field. Throughout the course, either individually or with partners, you will develop an independent project that explores the design of K–12 computer science learning experiences. Some examples of possible projects include: designing CS-standalone or cross-curricular learning activities and curriculum, building a programming language for novices, developing an annotated bibliography, critically analyzing policy documents such as curriculum frameworks and standards from around the world, or contributing to current K–12 CS education research initiatives. (Harvard)

MIT 6.1060: Software Performance Engineering (4) softeng

Project-based introduction to building efficient, high-performance and scalable software systems. Topics include performance analysis, algorithmic techniques for high performance, instruction-level optimizations, vectorization, cache and memory hierarchy optimization, and parallel programming. (Harvard)

6.1020: Software Construction (15) softeng

Introduces fundamental principles and techniques of software development. Topics include specifications and invariants; testing, test-case generation, and coverage; abstract data types and representation independence; design patterns for object-oriented programming; concurrent programming, including message passing and shared memory concurrency, and defending against races and deadlock; and functional programming with immutable data and higher-order functions. (MIT)

6.1040: Software Design (18) softeng

Provides design-focused instruction on how to build complex software applications. Design topics include classic human-computer interaction (HCI) design tactics, conceptual design, social and ethical implications, abstract data modeling, and visual design. Implementation topics include reactive front-ends, web services, and databases. (MIT)

6.1060: Software Performance Engineering (6) softeng

CS 4500: Software Development (4) softeng

Considers software development as a systematic process involving specification, design, documentation, implementation, testing, and maintenance. Examines software process models; methods for software specification; modularity, abstraction, and software reuse; and issues of software quality. Students, possibly working in groups, design, document, implement, test, and modify software projects. (Northeastern)

CS 4530: Fundamentals of Software Engineering (4) softeng

Covers the fundamentals of software engineering, including software development life cycle models (e.g., waterfall, spiral, agile); requirements analysis; user-centered design; software design principles and patterns; testing (functional testing, structural testing, testing strategies); code refactoring and debugging; software architecture and design; and integration and deployment. Includes a course project in which some of the software engineering methods (from requirements analysis to testing) are applied in a team-based setting. (Northeastern)

COMP_SCI 310-0: Scalable Software Architectures (1) softeng

Teaches software design principles for building high-scale Internet services. Focuses on challenges arising when assembling software services that run on many machines in parallel and which require the coordination of multiple software applications. (Northwestern)

COMP_SCI 377-0: Game Design Studio (1) softeng

In this course, students will design and develop games using the Unity game engine, with focus on team-based projects and agile development practices. Lectures will cover game design theory, game architecture and implementation, and the business of game development. Students will participate in class discussion and evaluation of projects in progress, to develop their skills in iterative design and implementation. (Northwestern)

COMP_SCI 392-0: Rapid Prototyping for Software Innovation (1) softeng

This is a course about developing working prototypes of full-stack mobile web software applications in rapid iterations. Teams design and implement three distinct applications over ten weeks. These projects are the context for introducing (1) cross-functional team development, (2) lean agile value-first product development, and (3) specific web application frameworks and development tools, such as React, Firebase, Cypress, and Github Actions for continuous integration. (Northwestern)

COMP_SCI 393-0: Software Construction (1) softeng

Building software is a craft that requires careful design. This course teaches software design principles in a studio setting. Each week, students present their programs to the class for review. Together, the class evaluates the programs for correctness and, more importantly, clarity and design. Expect to learn how to build reliable, maintainable, extensible software and how to read others' codes. (Northwestern)

COMP_SCI 394-0: Agile Software Development (1) softeng

Developing mobile and web applications, using modern sustainable agile practices, such as backlogs, user stories, velocity charts, and test driven development, to deliver value as quickly as possible to end users, clients, developers, and the development organization. (Northwestern)

CS 30700: Software Engineering I (3) softeng

An introduction to the methods and tools of software engineering; software life cycle; specification and design of software, software testing, cost and effort estimation; laboratory exercises with design, testing, and other tools. (Purdue)

CS 36000: Software Engineering (3) softeng

The course presents the common forms of the software life cycle, which are used throughout the commercial, industrial, institutional, and even governmental communities when a single development effort is appropriate. We will discuss the nature of software and software projects, software development models, software design, software process maturity, project planning, management, and communication. We will study methods for analysis, design, testing, and implementation of various software systems. (Purdue)

CS 40800: Software Testing (3) softeng

Preliminaries: errors and testing; software quality, requirements, behavior, and correctness; testing, debugging, verification; control flow graphs, dominators; types of testing; Test selection: from requirements, finite state models, and combinatorial designs; regression testing and test minimization; Test adequacy assessment: control and data flow; mutation based; testing tools. (Purdue)

CS 51000: Software Engineering (3) softeng

Software life cycles, requirements engineering, software design, design of distributed systems, verification and validation, software architecture, process metrics and models, and research methods in software engineering. Typically offered Spring. (Purdue)

COMP 310: Advanced Object-Oriented Programming and Design (4) softeng

Discover how state-of-the-art object-orient programming and design techniques can create globe-spanning software systems that are both flexible and scalable. Learn how software design patterns are used in multiple programming paradigms. Explore highly decoupled systems with dynamically configurable behaviors. Highly recommended for anyone interested in building large systems and software engineering. (Rice)

COMP 318: Concurrent Program Design (4) softeng

Modern software systems are typically complex, event-driven, and require coordination across multiple components. Such systems require careful design to ensure that they uphold best practices in software design while supporting concurrency. This course will introduce principles of designing large-scale concurrent software and give students practice implementing these principles in the context of large-scale, highly concurrent software systems. Topics covered will include concurrency vs. parallelism, concurrency concepts and mechanisms, and principles of software design including encapsulation, composition, decoupling, and accessibility. (Rice)

COMP 402: Production Programming (4) softeng

This course focuses on the principles and practices of test-driven software development, which have been popularized under the banner of 'Extreme Programming.' To provide students with practical experience, the course engages students in the development of open source production programs written in JAVA or C#. The DRJAVA programming courses was developed by students in this course. Some of the major topics covered in course lectures include design patterns for controlling concurrency and refactoring transformations to improve legacy code. (Rice)

COMP 405: Advanced Topics in Object-Oriented Design (4) softeng

A topics-driven exploration of cutting-edge object oriented design issues and concepts including mutable recursive data frameworks, design patterns for sorting, parsing and games, service-oriented architectures and cloud computing. Detailed knowledge and practice in abstract structure and behavioral representations, delegation model programming, design patterns and Java are required. (Rice)

COMP 410: Software Engineer Methodology (4) softeng

COMP 410 is a pure discovery-based learning course designed to give students real-life, hands-on training in a wide variety of software engineering issues that arise in creating large-scale, state-of-the-art software systems. The class forms a small software development 'company' that works to deliver a product to a customer. The topics encountered include and are not limited to, dealing with new technologies (e.g. C#, .NET, distributed computing), advanced object-oriented programming and design, interacting with customers, problem specification and tasking, individual and group communications, human resource management, group leadership, testing, integration and documentation. Traditional development cycle methodologies will be compared to recent, 'agile' techniques. (Rice)

COMP 415: Real-World Software Development (4) softeng

Experience real customers, software, and situations. The class will be contracted by an industrial customer to design build, and deliver a product. Negotiate to finalize specifications, updates, and delivery schedules Encounter real-life issues such as team management, intellectual property, and vagueness and specification changes while developing a state-of-the-art software application. (Rice)

CSSE 371: Software Requirements Engineering (4) softeng

Basic concepts and principles of software requirements engineering, its tools and techniques, and methods for modeling software systems. Topics include requirements elicitation, prototyping, functional and non-functional requirements, object-oriented techniques, and requirements tracking. (Rose-Hulman)

CSSE 372: Software Project Management (4) softeng

Major issues and techniques of project management. Project evaluation and selection, scope management, team building, stakeholder management, risk assessment, scheduling, quality, rework, negotiation, and conflict management. Professional issues including career planning, lifelong learning, software engineering ethics, and the licensing and certification of software professionals. (Rose-Hulman)

CSSE 373: Formal Methods in Specification and Design (4) softeng

Introduction to the use of mathematical models of software systems for their specification and validation. Topics include finite state machine models, models of concurrent systems, verification of models, and limitations of these techniques. (Rose-Hulman)

CSSE 374: Software Design (4) softeng

Introduction to the architecture and design of complete software systems, building on components and patterns. Topics include architectural principles and alternatives, design documentation, and relationships between levels of abstraction. (Rose-Hulman)

CSSE 375: Software Construction and Evolution (4) softeng

Issues, methods and techniques associated with constructing software. Topics include detailed design methods and notations, implementation tools, coding standards and styles, peer review techniques, and maintenance issues. (Rose-Hulman)

CSSE 376: Software Quality Assurance (4) softeng

Theory and practice of determining whether a product conforms to its specification and intended use. Topics include software quality assurance methods, test plans and strategies, unit level and system level testing, software reliability, peer review methods, and configuration control responsibilities in quality assurance. (Rose-Hulman)

CSSE 477: Software Architecture (4) softeng

This is a second course in the architecture and design of complete software systems, building on components and patterns. Topics include architectural principles and alternatives, design documentation, relationships between levels of abstraction, theory and practice of human interface design, creating systems which can evolve, choosing software sources and strategies, prototyping and documenting designs, and employing patterns for reuse. (Rose-Hulman)

CS 190: Software Design Studio (34) softeng

This course teaches the art of software design: how to decompose large complex systems into classes that can be implemented and maintained easily. Topics include the causes of complexity, modular design, techniques for creating deep classes, minimizing the complexity associated with exceptions, in-code documentation, and name selection. The class involves significant system software implementation and uses an iterative approach consisting of implementation, review, and revision. The course is taught in a studio format with in-class discussions and code reviews in addition to lectures. (Stanford)

CS 210A: Software Project Experience with Corporate Partners (34) softeng

Two-quarter project course. Focus is on real-world software development. Corporate partners seed projects with loosely defined challenges from their R&D labs; students innovate to build their own compelling software solutions. Student teams are treated as start-up companies with a budget and a technical advisory board comprised of instructional staff and corporate liaisons. Teams will typically travel to the corporate headquarters of their collaborating partner, meaning some teams will travel internationally. Open loft classroom format such as found in Silicon Valley software companies. Exposure to: current practices in software engineering; techniques for stimulating innovation; significant development experience with creative freedoms; working in groups; real-world software engineering challenges; public presentation of technical work; creating written descriptions of technical work. (Stanford)

CS 295: Software Engineering (3) softeng

Software specification, testing and verification. The emphasis is on automated tools for developing reliable software. The course covers material---drawn primarily from recent research papers---on the technology underlying these tools. Assignments supplement the lectures with hands-on experience in using these tools and customizing them for solving new problems. The course is appropriate for students intending to pursue research in program analysis and verification, as well as for those who wish to add the use of advanced software tools to their skill set. (Stanford)

CPSC 071: Software Engineering (1) softeng

Software engineering is the application of systematic, measurable, and disciplined approach to the creation of computer programs. In this course, students will learn how to plan, organize, and maintain large software projects. Topics include software development methodologies, design principles, collaboration techniques, the use of modern libraries and frameworks, quality assurance, and timeline management. (Swarthmore)

CSCE 315: Programming Studio (3) softeng

Intensive programming experience that integrates core concepts in Computer Science and familiarizes with a variety of programming/development tools and techniques; students work on 2 or 3 month-long projects each emphasizing a different specialization within Computer Science; focuses on programming techniques to ease code integration, reusability, and clarity. (Texas A&M)

CSCE 331: Foundations of Software Engineering (4) softeng

Intensive programming experience and provision of the fundamentals needed for larger-scale software development; integration of concepts in computer science and familiarization with a variety of programming and development tools and techniques; team projects each with an emphasis on a different specialization within computer science; emphasis on programming techniques to ease code integration and clarity; practical exposure to software-engineering processes through large-scale projects and specification and documentation. (Texas A&M)

CSCE 429: Software Development, Globalization and Culture Abroad (3) softeng

Software development cycle; software outsourcing model, execution and practices; software industries on products, services and consultancy; software globalization; and offshore development culture; travel abroad required. (Texas A&M)

CSCE 431: Software Engineering (3) softeng

Application of engineering approach to computer software design and development; life cycle models, software requirements and specification; conceptual model design; detailed design; validation and verification; design quality assurance; software design/development environments and project management. (Texas A&M)

CSCE 483: Computer Systems Design (3) softeng

Engineering design; working as a design-team member, conceptual design methodology, design evaluations, total project planning and management techniques, design optimization, systems manufacturing costs considerations. (Texas A&M)

CS403: Software Testing & Development (3) softeng

This course builds on the fundamental programming skills from prerequisite courses to explore advanced concepts used in modern object oriented software design to create software that is robust, reusable, and extensible in varying problem domains. Cadets gain confidence in their abilities to model, implement, and test solutions to demanding programming problems. (West Point)

CS 169A: Introduction to Software Engineering (4) softeng

Ideas and techniques for designing, developing, and modifying large software systems. Service-oriented architecture, behavior-driven design with user stories, cloud computing, test-driven development, automated testing, cost and quality metrics for maintainability and effort estimation, practical performance and security in software operations, design patterns and refactoring, specification and documentation, agile project team organization and management. (Berkeley)

CS 169L: Software Engineering Team Project (4) softeng

Open-ended design project enhancing or creating software for real customers in an agile team setting. Teamwork coordination, effective customer meetings, pre- and post-iteration team meetings, running scrums and standups, technical communication. Contributing as a team to an open-source project; tools and workflows associated with open source collaboration, including fork-and-pull, rebase, upstream merge, continuous deployment & integration. (Berkeley)

CSE 110: Software Engineering (4) softeng

Introduction to software development and engineering methods, including specification, design, implementation, testing, and process. An emphasis on team development, agile methods, and use of tools such as IDE’s, version control, and test harnesses. (UCSD)

CSE 112: Advanced Software Engineering (4) softeng

This course will cover software engineering topics associated with large systems development such as requirements and specifications, testing and maintenance, and design. Specific attention will be given to development tools and automated support environments. (UCSD)

CSE 125: Software System Design and Implementation (4) softeng

Design and implementation of large, complex software systems involving multiple aspects of CSE curriculum. Emphasis is on software system design applied to a single, large group project with close interaction with instructor. (UCSD)

CMPSC 148: Computer Science Project (4) softeng

Team-based project development. Topics include software engineering and professional development practices, interface design, advanced library support; techniques for team oriented design and development, testing and test driven development, and software reliability and robustness. Students present and demonstrate final projects. (UCSB)

CMPSC 156: Advanced Applications Programming (4) softeng

Advanced application programming using a high-level, virtual-machine-based language. Topics include generic programming, exception handling, automatic memory management, and application development, management, and maintenance tools, third-party library use, version control, software testing, issue tracking, code review, and working with legacy code. (UCSB)

CMPSC 172: Software Engineering (4) softeng

Software engineering is concerned with long-term, large-scale programming projects. Software management, cost estimates, problem specification and analysis, system design techniques, system testing and performance evaluation, and system maintenance. Students will design, manage, and implement a medium-sized project. (UCSB)

CS 222: Software Design Lab (1) softeng

Design and implementation of novel software solutions. Problem identification and definition; idea generation and evaluation; and software implementation, testing, and deployment. Emphasizes software development best practices—including framework selection, code review, documentation, appropriate library usage, project management, continuous integration and testing, and teamwork. (Illinois)

CS 427: Software Engineering I (3) softeng

Software process, analysis and design. Software development paradigms, system engineering, function-based analysis and design, and object-oriented analysis and design. Course will use team-projects for hands-on exercises. Same as CSE 426. (Illinois)

CS 428: Software Engineering II (3) softeng

Continuation of CS 427. Software development, management, and maintenance. Project and configuration management, collaborative development models, software quality assurance, interoperability domain engineering and software reuse, and software re-engineering. Same as CSE 429. (Illinois)

CS 429: Software Engineering II, ACP (3) softeng

Continuation of CS 427. Identical to CS 428 except for the additional writing component. See CS 428. (Illinois)

CS 470: Social and Information Networks (3) softeng

Social networks, auctions, and stock-markets appear to be very different phenomena, but they share a common foundation—the science of networks. The learning goal: to provide a broad, accessible introduction to the foundations of network science. We shall draw on ideas from mathematical sociology, and from game theory to understand strategic interaction over networks. We shall develop algorithms to identify network properties, and models for explaining network dynamics, including viral behavior. (Illinois)

CS 476: Program Verification (3) softeng

Formal methods for demonstrating correctness and other properties of programs. Invariant assertions; Hoare axiomatics; well-founded orderings for proving termination; structural induction; computational induction; data structures; parallel programs; overview of predicate calculus. (Illinois)

CS 477: Formal Software Development Methods (3) softeng

Mathematical models, languages, and methods for software specification, development, and verification. (Illinois)

CS 322: Introduction to Software Engineering (4) softeng

A project-intensive introduction to software engineering intended to build skills, knowledge, and habits of mind that prepare students for 400-level computer science courses, internships, and other software. (UO)

CS 422: Software Methodology I (4) softeng

Technical and nontechnical aspects of software development, including specification, planning, design, development, management and maintenance of software projects. Student teams complete projects. (UO)

CS 423: Software Methodology II (4) softeng

Application of concepts and methodologies covered in CS 422/CS 522. Student teams complete a large system design and programming project. Final system specification, test plan, user documentation, and system walk throughs. (UO)

CIS 3500: Software Design/Engineering (1) softeng

You know how to write a 'program'. But how do you create a software 'product' as part of a team, with customers that have expectations of functionality and quality? This course introduces students to various tools (source control, automated build systems, programming environments, test automation, etc.) and processes (design, implementation, testing, and maintenance) that are used by professionals in the field of software engineering. Topics will include: software development lifecycle; agile and test-driven development; source control and continuous integration; requirements analysis; object-oriented design and testability; mobile and/or web application development; software testing; refactoring ; and software quality metrics. (Penn)

CIS 5470: Software Analysis (1) softeng

This course covers the theory and practice of software analysis - a body of algorithms and techniques to reason about program behavior with applications to effectively test, debug, and secure large, complex codebases. The course surveys a wide range of applications of software analysis including proving the absence of common programming errors, discovering and preventing security vulnerabilities, systematically testing intricate data structures and libraries, and localizing root causes in complex software failures. (Penn)

CIS 5520: Advanced Programming (1) softeng

The goals of this course are twofold: (1) to take good programmers and turn them into excellent ones, and (2) to introduce them to a range of modern software engineering practices, in particular those embodied in advanced functional programming languages. (Penn)

CIS 5730: Software Engineering (1) softeng

Writing a "program" is easy. Developing a "software product", however, introduces numerous challenges that make it a much more difficult task. This course will look at how professional software engineers address those challenges, by investigating best practices from industry and emerging trends in software engineering research. Topics will focus on software maintenance issues, including: test case generation and test suite adequacy; code analysis; verification and model checking; debugging and fault localization; refactoring and regression testing; and software design and quality. (Penn)

CSCI 201L: Principles of Software Development (4) softeng

Object-oriented paradigm for programming in-the-large in Java; writing sophisticated concurrent applications with animation and graphic user interfaces; using professional tools on team project. (USC)

CSCI 310: Software Engineering (4) softeng

Introduction to the software engineering process and software lifecycle. Covers project management, requirements, architecture, design, implementation, testing, and maintenance phase activities in team based projects. (USC)

CTIN 389: Game Development Principles (4) softeng

Concepts and projects relating to the implementation and presentation of digital games; core level design preproduction techniques. (USC)

CTIN 489L: Intermediate Game Design and Production (4) softeng

A follow-up to the introductory game design class, this course will introduce more advanced concepts in game design and game theories, including ideation, digital prototyping and level design. (USC)

CMPU 203: Computer Science III: Software Design and Implementation (1) softeng

Focuses on the systematic application of scientific principles to the development of computer software, from requirements analysis to design, implementation, and testing. Covers techniques such as iterative development, use cases, and software design patterns, as well as tools such as source version control and Unified Modeling Language (UML) diagrams. Students consolidate knowledge by working in groups on the creation of a mobile application of their own design over the course of the semester. Rui Meireles. (Vassar)

CSE 237S: Programming Tools and Techniques (3) softeng

This course offers an introduction to the tools and techniques that allow programmers to write code effectively. Tools covered include version control, the command line, debuggers, compilers, unit testing, IDEs, bug trackers, and more. The course also places a heavy emphasis on code quality: how can we write code that is functional and that also meets quality standards? Peer review exercises will be used to show the importance of code craftsmanship. (Washington U.)

CSE 437S: Software Engineering Workshop (3) softeng

An introduction and exploration of concepts and issues related to large-scale software systems development. Areas of exploration include technical complexities, organization issues, and communication techniques for large-scale development. Students participate through teams emulating industrial development. The projects cover the principal system development life-cycle phases from requirements analysis, to software design, and to final implementation. Issues relating to real-time control systems, human factors, reliability, performance, operating costs, maintainability and others are addressed and resolved in a reasonable manner. (Washington U.)

CSE 454A: Software Engineering for External Clients (3) softeng

Teams of students will design and develop a solution to a challenging problem posed by a real-world client. Students will gain experience with a variety of facets of software development, such as gathering and interpreting requirements, software design/architecture, UI/UX, testing, documentation, and developer/client interactions. (Washington U.)

COMP 333: Software Engineering (1) softeng

Software engineering is the application of engineering principles to the software development process. Eliciting requirements from stakeholders, designing the architecture of a program, performing usability studies, and testing a codebase are some of the aspects that elevate program development to software engineering. Focusing on web and mobile apps, students in this course will gain expertise in state-of-the-art frontend, backend, and mobile technologies, as well as related tooling. We will also cover the collaborative organization of software projects, software licensing, software business models, and ethical considerations for professional software engineers. (Wesleyan)

CSCI 326: Software Methods (1) softeng

Sophisticated software systems play a prominent role in many aspects of our lives, and while programming can be a very creative and exciting process, building a reliable software system of any size is no easy feat. Moreover, the ultimate outcome of any programming endeavor is likely to be incomplete, unreliable, and unmaintainable unless principled methods for software construction are followed. This course explores those methods. Specific topics include: software processes; specifying requirements and verifying correctness; abstractions; design principles; software architectures; concurrentand scalable systems design; testing and debugging; and performance evaluation. (Williams)

CPSC 439: Software Engineering (1) softeng

Introduction to fundamental concepts in software engineering and to the development and maintenance of large, robust software systems. (Yale)

CPSC 454: Software Analysis and Verification (1) softeng

Introduction to concepts, tools, and techniques used in the formal verification of software. (Yale)