Computer Science II Metrics
Description
This course is the first in a three-course sequence that provides students with a foundation in computer science. Students develop fundamental programming skills using a language that supports an object-oriented approach, incorporating security awareness, human-computer interactions and social responsibility.
Among the associate-degree transfer programs, the Computer Science I-II-III coursework provides a common "core" body of knowledge in computing. The complete course sequence is designed in such a manner that students progress in knowledge, proficiency and professional maturity in several specific areas, including software engineering principles and professional and ethical conduct.
The progression of software engineering topics across CS I-II-III originates in CS I, where there is an emphasis on using a cyclic approach for program development by iterating through designing, coding, and testing program modules. Complemented by algorithm analysis, students are encouraged to think abstractly about problems and to begin developing processes for decomposing problems into organized parts. Encouraging clear documentation, good naming conventions and consistent secure coding style contribute to a disciplined approach to writing programs.
The progression of software engineering topics across CS I-II-III continues in CS II, where greater emphasis is placed on abstraction and sound software design principles, engaging students in the development of secure software components that solve a wide range of related problems and can be reused. The students determine the necessary elements of simple ADTs (such as a counter or a date) and then construct them; by their very nature, these components must be well-documented to encourage reuse. Additionally the students write assertions such as pre-conditions and post-conditions describing each class method, thereby encouraging students to think deeply about a simple problem before coding. After coding, the components must be well-tested, and therefore the use of test plans and test drivers are practiced. These activities reinforce the notion of constructing software from well-defined, independent pieces and complement the study of using existing library classes and APIs in software solutions.
The progression of software engineering topics across CS I-II-III concludes in CS III, where students are asked to step beyond the programmer role and take a broader view of software development; to consider its lifecycle from problem description to maintenance. Students first practice with analysis and design of medium-sized systems. Standard modeling tools are introduced and the students complete the phases of analysis, design, implementation and testing of a medium-sized team project that includes documents such as UML diagrams or CRC cards in addition to test plans. Students consider design patterns and write applications using data structures and templates. The software engineering topics are integrated with professionalism and ethics, as well as software and information assurance topics, such as security concerns and liabilities of computer-based systems.
The progression of the emphasis on professional and ethical conduct across CS I-II-III originates in CS I, where the curriculum is designed to consider the historical context of computing and programming as well as examining issues involving ethical conduct; plagiarism, intellectual property and software piracy issues are presented. Typically, student requirements for submitting original work as well as college policies regarding the use of computing resources and acceptable computing behavior on campus and the Brookings Institute "10 Commandments of Ethical Computing" can be used as relevant discussion starters.
The progression of the emphasis on professional and ethical conduct across CS I-II-III continues in CS II, which builds upon this foundation by examining societal issues, the Internet, and professionalism. Now that the students have gained some experience with developing programs, they can begin to see "what can go wrong" and the possible consequences to the user of their program, at a personal level, such as infinite loops and program crashes. Additionally, students are confronted with broader implications by design considerations regarding databases and data accessibility; ethical concerns regarding personal data, privacy and property rights should be explored Integrating these topics with the software development process, security issues, and relevant cases of software errors will help students recognize that their work can have individual as well as societal consequences and encourage them to think carefully about the design and implementation of their programs.
The progression of the emphasis on professional and ethical conduct across CS I-II-III concludes in CS III, where a broader view is presented - encompassing computing sciences as a profession. Standards of professional behavior, organizations and publications are examined as well as a variety of occupational roles in the computing field. Course content materials presenting case studies of significant software failures amplify the topics of risks and liabilities. The students should start to recognize that invariably software production involves ethical choices. Incorporating these topics with the software lifecycle, engineering, human factors, and software assurance considerations will help students internalize the significance of professional and ethical behavior and subsequently demonstrate it through their individual and group projects.
Minimum Contact Hours
42Assessment Rubric
CS. 2. Discuss significant trends and societal impacts related to computing, software, and the Internet.
Explains how databases and the Internet can impact privacy and property rights.
Discusses the potential uses and abuses of data and the consequences of the loss of privacy.
Practices ethical behavior when addressing property rights and privacy issues.
CS. 5. Analyze the execution of searching and sorting algorithms.
Describes the execution trace of one searching algorithm and one sorting algorithm.
Analyzes the execution of various searching and sorting algorithms.
Evaluates the execution of various searching and sorting algorithms including a recursive solution.
CS. 14. Construct multiple‐file or multiple‐module programming solutions that use class hierarchies, inheritance, and polymorphism to reuse existing design and code.
Describes when inheritance and the use of class hierarchies is an appropriate design strategy.
With guidance, produces a programming solution using inheritance and polymorphism.
Designs and constructs a programming solution using the features of inheritance and polymorphism appropriately.
CS. 15. Construct object oriented programming solutions for reuse, using ADTs that incorporate encapsulation, data abstraction, and information hiding.
Summarizes the concepts of encapsulation, data abstraction, and information hiding and explains how they apply to object-oriented programming.
Organizes programming solutions that include encapsulation, information hiding, and data abstraction.
Constructs reusable software components that incorporate encapsulation, data abstraction, and information hiding.
CS. 18. Create programming solutions that use data structures and existing libraries.
Produces programming solutions that use existing library code.
Organizes programming solutions that incorporate appropriate data structures and pre-existing code.
Designs and develops programming solutions that use data structures, pre-existing libraries, and individual library code.
CS. 23. Design and develop secure and fault-tolerant programs that mitigate potential security vulnerabilities.
Summarizes important characteristics of software assurance, such as the elimination of buffer overflows, memory leaks and back-door access.
Produces a fault-tolerant program using the foundations of software assurance to mitigate potential security vulnerabilities.
Designs and develops a secure and fault-tolerant programming solution utilizing principles of software assurance.
CS. 30 Produce graphical user interfaces that incorporate simple color models and handle events.
Differentiates between good and bad design concepts for human-computer interfaces.
Produces programming code of a graphical user interface that utilizes a simple color model effectively and efficiently handles events triggered by user interaction.
Develops programming code for a graphical user interface that incorporates the concepts of good HCI design.
CS. 34. Verify program correctness through the development of sound test plans and the implementation of comprehensive test cases.
Produces test plans for object - oriented programming solutions that considers code coverage.
Analyzes a program and devises a test plan that examines code coverage and develops test cases for data coverage.
Constructs a test driver for code coverage and creates a formal test plan choosing comprehensive test cases for data coverage.