Software Development Fundamentals (SDF)
Fluency in the process of software development is fundamental to the study of computer science. In order to use computers to solve problems most effectively, students must be competent at reading and writing programs in multiple programming languages. Beyond programming skills, however, they must be able to design and analyze algorithms, select appropriate data structures, and utilize modern development and testing tools. This knowledge area brings together those fundamental concepts and skills related to the software development process.
SDF focuses on the software development process, identifying those concepts and skills that should be mastered early in a computer science program, typically in the first year. The 43 hours of material in this knowledge area will typically be augmented with core material from other knowledge areas to form a complete and coherent experience as students progress to mid- and upper-level courses. Many software development topics will reappear in more detail and be reinforced by later topics. This knowledge area assumes that a contemporary programming language with good built-in support for common data types including for associative data types like maps/ dictionaries is being used for introducing students to programming (e.g. Python, Java). However, this is not to discourage the use of older or lower-level languages for SDF – the knowledge units below can be suitably adapted for the actual language used.
SDF Knowledge Units
| Core-Tier1 hours | Core-Tier2 hours | Includes Electives | |
| SDF/Fundamental Programming Concepts | 10 | ||
| SDF/Fundamental Data Structures | 12 | ||
| SDF/Algorithms and Design | 11 | ||
| SDF/Development Methods | 10 |
SDF/Fundamental Programming Concepts
[10 Core-Tier1 hours]
This knowledge unit aims to develop core programming concepts through one or more programming languages. It focuses on understanding of basic concepts (e.g., variables, types, expressions), and fluent use of basic constructs (e.g., assignments, conditionals, iteration) as well as modularity constructs (e.g., functions, including recursion, and classes/objects). It also aims to familiarize students with some widely used libraries, frameworks, including those to facilitate API-based access to resources.
Topics
- Basic concepts such as variables, primitive data types, expression evaluation, assignment, etc.
- Basic constructs such as conditional and iterative structures and flow of control
- Key modularity constructs such as functions/methods and classes, and related concepts like parameter passing, scope, abstraction, data hiding, class invariants, etc.
- Input and output using files, console, and APIs
- Structured data types available in the chosen programming language like sequences (arrays, lists, etc), associative containers (dictionaries, maps, etc), others (sets, tuples, etc.) and when and how to use them.
- Libraries and frameworks provided by the language (when/where applicable)
- Recursion
- How programs are executed by the underlying system
- Dealing with compile time and runtime errors
- Programming style that improves readability
Learning Outcomes
- Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: assignment and expressions, simple I/O, conditional and iterative structures, functions with parameter passing.
- Design, implement, test, and debug a program that effectively uses the different structured data types provided in the language like strings, arrays/lists, dictionaries, sets
- Write a program that uses file I/O to provide persistence across multiple executions.
- Write a program that uses APIs to get data (e.g. from the web, where applicable)
- Demonstrate the use of language-provided libraries and frameworks in programs (where applicable).
- Create simple classes and instantiate objects of those classes (if supported by the language)
- Understand the concept of recursion, and when and how to use it effectively.
- Understand the flow of control during the execution of a program.
- Understand what programming practices, including commenting, aid readability of programs, and apply them in writing programs
- Understand that limited testing usually done does not assure correctness of a program
SDF/Fundamental Data Structures
[12 Core-Tier1 hours]
This unit aims to develop core concepts relating to Data Structures including associated algorithms. Students should understand the important data structures (often available in the programming language or as libraries) for modern applications, and how to use them effectively. This includes choosing appropriate data structures while designing solutions for a given problem.
Topics
- Standard abstract data types such as lists, stacks, queues, sets, and maps/dictionaries
- When and how to use standard data structures
- Strings and string processing
- Understand the impact that choice of data structure(s) has on performance
Learning Outcomes
- Write programs that use each of the abstract data types provided in the language like arrays, tuples/records/structs etc (depending on the language), lists, stacks, queues, and including associative data types like sets, maps / dictionaries.
- Ability to choose the appropriate data structure for a given problem.
- Write programs that work with text by using string processing capabilities provided by the language.
- Measure the performance of a program (e.g. to assess how performance changes with scale, to compare alternative implementations, …).
SDF/Algorithms and Design
[11 Core-Tier1 hours]
This unit aims to develop the foundations of efficient algorithms design and their analysis. The KU should also empower students in selecting and modifying suitable algorithms for building modest-complexity applications.
- Concept of algorithm and notion of algorithm efficiency
- Common algorithms like: Sorting, Searching, Tree traversal, Graph traversal, etc.
- Assessing the time/space efficiency of an algorithms through measurements
Learning Outcomes
- Discuss the importance of algorithms in the problem-solving process.
- Discuss how a problem may be solved by multiple algorithms, each with different properties.
- Understand common algorithms like: Sorting, Searching, Tree traversal, Graph traversal, etc.
- Understand and experience (through experimentation) space/time performance of some algorithms.
SDF/Development Methods
[10 Core-Tier1 hours]
This unit develops the core concepts relating to modern software development methods. Its aim is to develop student understanding and basic competencies in using modern methods and tools, including some general purpose IDE, source code control, use of debuggers, unit testing, etc. It should also empower students with the ability to discover solutions to the technical problems they face in their software development using suitable internet based resources.
Topics:
- Reading and understanding code
- Basic unit testing (using suitable frameworks) including test case design
- Basic source code control
- Use of a general purpose IDE, including its debugger (which can be also used to strengthen some programming concepts)
- Finding solutions for technical issues using blogs, platforms like stackoverflow, online tutorials and resources, etc
Learning Outcomes
- Ability to read, understand, and review code written by someone else
- Construct, execute and debug programs using a modern IDE and associated tools such as visual debuggers.
- Use basic source code control tools and methods while writing code (potentially using facilities of the IDE).
- Use unit testing frameworks for developing tests for modules, and apply a variety of strategies to design test cases.
- Identify suitable online resources such as community forums to resolve issues faced during programming.
SDF/Cross Cutting Concerns
Though there are linkages with other KAs (e.g. SE, Ethics, etc), as SDF focuses on the first year, it does not depend on any to deliver its KUs and LOs. It is leaving these other competencies to be developed naturally in the respective areas.
SDF/Desirable Professional Dispositions
Dispositions are not likely to be topics to be “taught”; they are more likely to be attributes whose development in students can be facilitated – perhaps by nudging them rather than teaching. Given that SDF is about “foundations”, some suggested dispositions are:
- Growth-mindset towards programming. Treat problems that come during programming as temporary hurdles and opportunities to learn and grow.
-
-
- When tricky bugs, subtle language issues, or other challenges come up – look up resources on the internet (e.g. using community forums) to resolve them
- Learn from coding practices and standards, blogs of star programmers for advice on how to execute some task, …
- Explore outside the course activities to practice programming (e.g. programming contests, hackathons, …)
-
- Technical Curiosity. e.g.
- Look underneath your program – what is happening, how the program is running, understand the energy consumed by your program and why it changes, etc. (Can be encouraged by having students look at the byte code, stack, etc; )
- Experiment. For questions about language features and how some combinations behave – not just read about it, but try it by writing programs and observing behavior (can be encouraged easily)
SDF/Subcommittee
The subcommittee for SDF is:
- Pankaj Jalote, Chair, IIIT-Delhi, Delhi, India
- Brett A. Becker, University College Dublin, Ireland
- Titus Winters, Google, New York City, NY, USA
- Andrew Luxton-Reilly, University of Auckland, New Zealand
- Viraj Kumar, ACM India Education Committee, India
- Christian Servin, El Paso Community College, Texas, USA
- Karen Reid, University of Toronto, Canada
- Adrianne Decker, University at Buffalo, USA