Course Design
How I Design Courses
All FGCU Courses
Design Influences
Success
Success in this course
Preparation for future courses and a career
Course Student Learning Outcomes developed by College / State Common Course Number Outcomes
Acceptable evidence (how can achievement of outcomes be measured and proven)
Catalog Course Description / State Common Course Number Description
The Software Engineering Program Educational Objectives (PEOs)
The Software Engineering Program in the U.A. Whitaker College of Engineering at Florida Gulf Coast University will produce graduates who
i. successfully enter chosen careers in the application software development, system software development, and/or graduate studies;
ii. practice life-long learning in their professions, adapting to the rapidly changing technological world.
The Student Outcomes (SOs) for the B.S. in Software Engineering degree (the same as the Accreditation Board for Engineering and Technology (ABET) Student Outcomes)
Graduates from the Software Engineering program will attain:
(a) An ability to apply knowledge of computing and mathematics appropriate to the program’s student outcomes and to the discipline
(b) An ability to analyze a problem, and identify and define the computing requirements appropriate to its solution
(c) An ability to design, implement, and evaluate a computer-based system, process, component, or program to meet desired needs
(d) An ability to function effectively on teams to accomplish a common goal
(e) An understanding of professional, ethical, legal, security and social issues and responsibilities
(f) An ability to communicate effectively with a range of audiences
(g) An ability to analyze the local and global impact of computing on individuals, organizations, and society
(h) Recognition of the need for and an ability to engage in continuing professional development
(i) An ability to use current techniques, skills, and tools necessary for computing practice.
IEEE/ACM Curriculum Guidelines for Undergraduate Degree Programs in Software Engineering (SEEK), a subset of the Software Engineering Body of Knowledge (SWEBOK). SEEK just lists topics, SWEBOK provides information about them.
IEEE/ACM Curriculum Guidelines for Undergraduate Degree Programs in Computer Science
The FGCU Software Engineering undergraduate program will be internationally recognized for excellence in education for:
delivering graduates with a high quality education in engineering and computer science who are well prepared for careers as valuable contributors in application software development, system software development, as well as for further graduate study;
providing an entrepreneurial, interdisciplinary, and service oriented environment and curriculum;
valuing diversity and professionalism in our field, and collaboration across the engineering and computing disciplines.
To produce engineering leaders ... with strong technical competence and professional skills to meet the challenges of Southwest Florida and beyond.
Course Specific Design Influence
COP 1500
SWEBOK / SEEK
SEEK 4.8 Computing essentials (CMP)
Computer science foundations (cf)
SWEBOK Ch. 13 Computing Foundations
Association for Computing Machinery (ACM) Curricula Recommendations
Introduction to most Knowledge Areas
Focus on SDF - Software Development Fundamentals
COP 2006
Association for Computing Machinery (ACM) Curricula Recommendations
Software Development Fundamentals (SDF)
SDF/Algorithms and Design
SDF/Fundamental Programming Concepts
SDF/Fundamental Data Structures
SDF/Development Methods (brief introduction, addressed more in COP 2001)
Topics from the Programming Languages, Software Engineering, Platform-Based Development, and Parallel and Distributed Computing Knowledge Areas
COP 2001
Association for Computing Machinery (ACM) Curricula Recommendations
SDF/Development Methods
[10 Core-Tier1 hours]
This unit builds the foundation for core concepts in the Software Engineering knowledge area, most notably in the Software Processes, Software Design and Software Evolution knowledge units.
Topics:
Program comprehension
Program correctness
Types of errors (syntax, logic, run-time)
The concept of a specification
Defensive programming (e.g. secure coding, exception handling)
Code reviews
Testing fundamentals and test-case generation
The role and the use of contracts, including pre- and post-conditions
Unit testing
Simple refactoring
Modern programming environments
Code search
Programming using library components and their APIs
Debugging strategies
Documentation and program style
Learning Outcomes: (ACMLOs)
1. Trace the execution of a variety of code segments and write summaries of their computations. [Assessment]
2. Explain why the creation of correct program components is important in the production of high-quality software. [Familiarity]
3. Identify common coding errors that lead to insecure programs (e.g., buffer overflows, memory leaks, malicious code) and apply strategies for avoiding such errors. [Usage]
4. Conduct a personal code review (focused on common coding errors) on a program component using a provided checklist. [Usage]
5. Contribute to a small-team code review focused on component correctness. [Usage]
6. Describe how a contract can be used to specify the behavior of a program component. [Familiarity]
7. Refactor a program by identifying opportunities to apply procedural abstraction. [Usage]
8. Apply a variety of strategies to the testing and debugging of simple programs. [Usage]
9. Construct, execute and debug programs using a modern IDE and associated tools such as unit testing tools and visual debuggers. [Usage]
10. Construct and debug programs using the standard libraries available with a chosen programming language. [Usage]
11. Analyze the extent to which another programmer’s code meets documentation and programming style standards. [Assessment]
12. Apply consistent documentation and program style standards that contribute to the readability and maintainability of software. [Usage]
COP 3003
Association for Computing Machinery (ACM) Curricula Recommendations
PL/Object-Oriented Programming
[4 Core-Tier1 hours, 6 Core-Tier2 hours]
Topics:
[Core-Tier1]
Object-oriented design
Decomposition into objects carrying state and having behavior
Class-hierarchy design for modeling
Definition of classes: fields, methods, and constructors
Subclasses, inheritance, and method overriding
Dynamic dispatch: definition of method-call
[Core-Tier2]
Subtyping (cross-reference PL/Type Systems)
Subtype polymorphism; implicit upcasts in typed languages
Notion of behavioral replacement: subtypes acting like supertypes
Relationship between subtyping and inheritance
Object-oriented idioms for encapsulation
Privacy and visibility of class members
Interfaces revealing only method signatures
Abstract base classes
Using collection classes, iterators, and other common library components
Learning outcomes: (ACMLOs)
[Core-Tier1]
1. Design and implement a class. [Usage]
2. Use subclassing to design simple class hierarchies that allow code to be reused for distinct subclasses. [Usage]
3. Correctly reason about control flow in a program using dynamic dispatch. [Usage]
4. Compare and contrast (1) the procedural/functional approach (defining a function for each operation with the function body providing a case for each data variant) and (2) the object-oriented approach (defining a class for each data variant with the class definition providing a method for each operation). Understand both as defining a matrix of operations and variants. [Assessment]
[Core-Tier2]
5. Explain the relationship between object-oriented inheritance (code-sharing and overriding) and subtyping (the idea of a subtype being usable in a context that expects the supertype). [Familiarity]
6. Use object-oriented encapsulation mechanisms such as interfaces and private members. [Usage]
7. Define and use iterators and other operations on aggregates, including operations that take functions as arguments, in multiple programming languages, selecting the most natural idioms for each language. [Usage]
PL/Event-Driven and Reactive Programming
[2 Core-Tier 2 hours]
Topics:
Events and event handlers
Canonical uses such as GUIs, mobile devices, robots, servers
Using a reactive framework
Defining event handlers/listeners
Main event loop not under event-handler-writer’s control
Externally-generated events and program-generated events
Separation of model, view, and controller
Learning outcomes:
1. Write event handlers for use in reactive systems, such as GUIs. [Usage]
2. Explain why an event-driven programming style is natural in domains where programs react to external events. [Familiarity]
3. Describe an interactive system in terms of a model, a view, and a controller. [Familiarity]
Java SE 8 Programmer II Exam Number: 1Z0-809 (1Z0-808 / OCAJP 8 is a prerequisite)
Gaining familiarity with IntelliJ IDEA
COP 3530
Association for Computing Machinery (ACM) Curricula Recommendations
AL/Basic Analysis
[2 Core-Tier1 hours, 2 Core-Tier2 hours]
AL/Algorithmic Strategies
[5 Core-Tier1 hours, 1 Core-Tier2 hours]
AL/Fundamental Data Structures and Algorithms
[9 Core-Tier1 hours, 3 Core-Tier2 hours]
This knowledge unit builds directly on the foundation provided by Software Development Fundamentals (SDF), particularly the material in SDF/Fundamental Data Structures and SDF/Algorithms and Design.
Topics:
[Core-Tier1]
Simple numerical algorithms, such as computing the average of a list of numbers, finding the min, max, and mode in a list, approximating the square root of a number, or finding the greatest common divisor
Sequential and binary search algorithms
Worst case quadratic sorting algorithms (selection, insertion)
Worst or average case O(N log N) sorting algorithms (quicksort, heapsort, mergesort)
Hash tables, including strategies for avoiding and resolving collisions
Binary search trees
Common operations on binary search trees such as select min, max, insert, delete, iterate over tree
Graphs and graph algorithms
Representations of graphs (e.g., adjacency list, adjacency matrix)
Depth- and breadth-first traversals
[Core-Tier2]
Heaps
Graphs and graph algorithms
Shortest-path algorithms (Dijkstra’s and Floyd’s algorithms)
Minimum spanning tree (Prim’s and Kruskal’s algorithms)
Pattern matching and string/text algorithms (e.g., substring matching, regular expression matching, longest common subsequence algorithms)
Learning Outcomes: (ACMLOs)
[Core-Tier1]
1. Implement basic numerical algorithms. [Usage]
2. Implement simple search algorithms and explain the differences in their time complexities. [Assessment]
3. Be able to implement common quadratic and O(N log N) sorting algorithms. [Usage]
4. Describe the implementation of hash tables, including collision avoidance and resolution. [Familiarity]
5. Discuss the runtime and memory efficiency of principal algorithms for sorting, searching, and hashing. [Familiarity]
6. Discuss factors other than computational efficiency that influence the choice of algorithms, such as programming time, maintainability, and the use of application-specific patterns in the input data. [Familiarity]
7. Explain how tree balance affects the efficiency of various binary search tree operations. [Familiarity]
8. Solve problems using fundamental graph algorithms, including depth-first and breadth-first search. [Usage]
9. Demonstrate the ability to evaluate algorithms, to select from a range of possible options, to provide justification for that selection, and to implement the algorithm in a particular context. [Assessment]
[Core-Tier2]
10. Describe the heap property and the use of heaps as an implementation of priority queues. [Familiarity]
11. Solve problems using graph algorithms, including single-source and all-pairs shortest paths, and at least one minimum spanning tree algorithm. [Usage]
12. Trace and/or implement a string-matching algorithm. [Usage]