Software Development

Course Description (same as traditional course in current catalog)

CSC3004 Introduction to Software Development [4]. An introductory course in software development. Concepts include software specifications and design, methodologies for software organization and development, user interfaces, file processing techniques, and software debugging, testing, and documentation.

Prerequisite: CSC2033 Data Structures and Algorithm Design.

Topic: Software Design

  • Fundamental design concepts and principles
  • The role and the use of contracts
  • Design patterns
  • Software architecture
  • Structured design
  • Object-oriented analysis and design
  • Component-level design
  • Design qualities
  • Internal including low coupling, high cohesion, information hiding, efficiency
  • External including reliability, maintainability, usability, performance
  • Other approaches: data-structured centered, aspect oriented, function oriented, service oriented, agile
  • Design for reuse
  • Use of open-source materials
Learning Objectives:
  1. Discuss the properties of good software design including the nature and the role of associated documentation.
  2. Evaluate the quality of multiple software designs based on key design principles and concepts.
  3. Select and apply appropriate design patterns in the construction of a software application.
  4. Create and specify the software design for a medium-size software product using a software requirement specification, an accepted program design methodology (e.g., structured or object-oriented), and appropriate design notation.
  5. Conduct a software design review of open-source materials using appropriate guidelines.
  6. Evaluate a software design at the component level.
  7. Evaluate a software design from the perspective of reuse.

Topic: Using APIs

  • Programming using APIs
  • Design of APIs
  • Class browsers and related tools
  • Debugging in the API environment Introduction to component-based computing
  • Introduction to Component-based Computing
Learning Objectives:
  1. Explain the value of application programming interfaces (APIs) in software development.
  2. Use class browsers and related tools during the development of applications using APIs.
  3. Design, implement, test, and debug programs that use large-scale API packages.

Topic: Secure Programming

  • Important of checking for and avoiding array and string overflows
  • Programming language constructs to avoid and alternatives
  • How attackers use overflows to smash the run-time stack PF/FundamentalConstructs [core] Minimum core coverage time: 9 hours Topics:
  • Basic syntax and semantics of a higher-level language
  • Variables, types, expressions, and assignment
  • Simple I/O
  • Conditional and iterative control structures
  • Functions and parameter passing
  • Structured decomposition
Learning Objectives:
  1. Analyze and explain the behavior of simple programs involving the fundamental programming constructs covered by this unit.
  2. Modify and expand short programs that use standard conditional and iterative control structures and functions.
  3. Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, and the definition of functions.
  4. Choose appropriate conditional and iteration constructs for a given programming task.
  5. Apply the techniques of structured (functional) decomposition to break a program into smaller pieces.
  6. Describe the mechanics of parameter passing.

Topic: Human Factors Foundations
• Motivation: Why the study of how people interact with technology is vital for the development of most usable and acceptable systems
• Contexts for HCI (mobile devices, consumer devices, business applications, web, business applications, collaboration systems, games, etc.)
• Process for user-centered development: early focus on users, empirical testing, iterative design.
• Different measures for evaluation: utility, efficiency, learnability, user satisfaction.
• Models that inform human-computer interaction (HCI) design: attention, perception and recognition, movement, and cognition.
• Social issues influencing HCI design and use: culture, communication, and organizations.
• Accommodating human diversity, including universal design and accessibility and designing for multiple cultural and linguistic contexts.
• The most common interface design mistakes.
• User interface standards
Learning Objectives:
1. Discuss why user-centered product development is important.
2. Explain why both individual human models and social models are important to consider in design of humancomputer interaction.
3. Define a user-centered design process that explicitly recognizes that the user is not like the developer or her acquaintances.
4. Describe ways in which a user-centered design process may fail, including examples.
5. Define different processes for defining interfaces for different contexts.
6. Differentiate between the role of hypotheses and experimental results vs. correlations.
7. Choose between qualitative and quantitative evaluation methods for a given evaluation question.
8. Use vocabulary for analyzing human interaction with software: perceived affordance, conceptual model, mental model, metaphor, interaction design, feedback, and so forth.
9. Provide examples of how different interpretations that a given icon, symbol, word, or color can have in (a) two different human cultures and (b) in a culture and one of its subcultures.
10. Be able to describe at least one national or international user interface design standard

Topic: Building GUI Interfaces

• Principles of graphical user interfaces (GUIs).

• Action-object versus object-action.
• User interface events.
• Constructing a user-interface for a native system vs. the web.

Learning Objectives:
1. Explain principles for design of user interfaces, such as learnability, flexibility, and robustness.
2. Describe examples of bad navigation, bad screen layout, and incomprehensible interface design.
3. Create a simple application that supports a graphical user interface, for either the Web or a windowing system.
4. Observe a user attempting to use the application and have the user critique the application.
5. Explain how careful user evaluation goes beyond the simple observation of a single user.

Topic: User Centered Software Evaluation

• Evaluation without typical users: walkthroughs, KLM, expert-based analysis, heuristics, guidelines, and
standards
• Evaluation with typical users: observation, think-aloud, interview, survey, experiment.
• Challenges to effective evaluation: sampling, generalization.
• Reporting the results of evaluations

Learning Objectives:

1. Discuss evaluation criteria: task time/completion, time to learn, retention, errors, and user satisfaction.
2. Conduct a walkthrough, expert-based analysis, and a Keystroke Level Model (KLM) analysis.
3. Compare a given user interface to a set of guidelines or standards to identify inadequacies.
4. Conduct a usability test with more than one user, gathering results using at least two different methods.
5. Compare a laboratory test to a field test.
6. Explain a usability problem that is supported by results from a usability test. Recommend a solution to thevusability problem.
7. Critique a user evaluation, to point out threats to validity.
8. Given an evaluation context (e.g. amount of time, availability of test users, place in the design process,
evaluation goals), recommend and justify an evaluation method.

Topic: User Centered Software Development

• Approaches, characteristics, and overview of product development process, with special emphasis on softwarevdevelopment process.
• Functionality and usability requirements
• Techniques for gathering requirements: task analysis, interviews, surveys
• Notations for specifying user interfaces
• Prototyping techniques and tools
• Sketching
• Paper storyboards
• Low-fidelity or paper prototyping
• Medium fidelity prototyping
• Prototyping tools and GUI builders
• User-interface software techniques:
• Inheritance and dynamic dispatch
• Prototyping languages and GUI builders

Learning Objectives:
1. Compare user-centered development to traditional software engineering methods.
2. Gather requirements for a user interface, using both task analysis and interview with a user.
3. Identify from requirements analysis at least three functional requirements and at least three usability requirements.
4. Create a specification for a user interface based on requirements.
5. Create two different prototypes at different levels of specificity from the specification.
6. Implement the prototype using some GUI toolkit.

Topic: GUI Design

• Choosing interaction styles (command line, menu, voice, gestural, WIMP) and interaction techniques
• Choosing the right widget for users and tasks
• HCI aspects of screen design: layout, color, fonts, labeling
• Handling human/system failure.
• Beyond simple screen design: visualization, representation, metaphor
• Multi-modal interaction: graphics, sound, and haptics.
• 3D interaction and virtual reality
• Designing for small devices, e.g., cell phones.
• Multi-cultural interaction and communication

Learning Objectives:

7. Summarize common interaction styles.
8. Explain good design principles of each of the following: common widgets; sequenced screen presentations;
simple error-trap dialog; a user manual.
9. Design, prototype, and evaluate a simple 2D GUI illustrating knowledge of the concepts taught in HC3 and HC4.
10. Identify the challenges that exist in moving from 2D to 3D interaction.
11. Identify the challenges that exist in moving from desktop or laptop screen to a mobile device.

Topic: GUI Programming

• UIMS, dialogue independence and levels of analysis, Seeheim model
• Widget classes and libraries
• Event management and user interaction
• Web design vs. native application design
• Geometry management
• GUI builders and UI programming environments
• Cross-platform design
• Design for small, mobile devices

Learning Objectives:

1. Differentiate between the responsibilities of the UIMS and the application.
2. Differentiate between kernel-based and client-server models for the UI.
3. Compare the event-driven paradigm with more traditional procedural control for the UI.
4. Describe aggregation of widgets and constraint-based geometry management.
5. Explain callbacks and their role in GUI builders.
6. Identify at least three differences common in cross-platform (e.g., desktop, Web, and cell phone) UI design.
7. Identify as many commonalities as you can that are found in UIs across different platforms.
Topic revision: r5 - 2013-10-24 - RobertKasper
 
This site is powered by the TWiki collaboration platformCopyright &© by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback