50.003 Elements of Software Construction

Home / Education / Undergraduate / Courses / 50.003 Elements of Software Construction

Course Description

This course is an introduction to the fundamental principles and techniques of software construction that have greatest impact on practice. Topics include capturing the essence of a problem by recognizing and inventing suitable abstractions; key paradigms, including basic concepts of software design and their expression using notations from Unified Modeling Language (UML); software testing, automated software test generation, automated software security testing via blackbox, greybox and whitebox fuzzing approaches, detection and removal of software code smells, software coding standards to avoid security loopholes, concurrent programming, including programming with threads and processes, understanding concurrency problems like deadlock and data race. This course includes exercises in software design, implementation, testing and reasoning.


Learning Objectives

  1.  Design medium-scale software system from scratch: formulating and analyzing the problem to be solved; writing formal software requirements, exploring and formulating system designs; and using extensive and systematic testing and reasoning to ensure quality.
  2. Apply key software engineering ideas, including invariants, decoupling, and data abstraction.
  3. Apply key software engineering ideas, including software design, specification, abstraction, verification and correctness.
  4. Apply widely used design concepts and notations (UML diagrams) and patterns in exploring and articulating problems and designs.
  5. Learning effective techniques on ensuring quality of large-scale software systems.
  6. Apply concepts of systematic software testing to discover bugs (including security vulnerabilities) in large-scale software systems.
  7. Apply concepts to reason about the security loopholes in software systems.
  8. Learning secure software coding standards.
  9. Learning key concepts in developing concurrent programs.
  10. Learning key concepts in reasoning and testing concurrent programs.

Measurable Outcomes

  1. Build medium-scale software prototype (LO 1-5).
  2. Design solution to questions related to the requirement prior to software development. (LO1, LO2 and LO4).
  3. Design blackbox, whitebox and diabolic software tests for validating software prototype. (LO6).
  4. Design critical part of the software by reasoning about its security. (LO8).
  5. Design small/medium-scale concurrent programs. (LO9).
  6. Design techniques to reason about the correctness of the concurrent programs (LO10).
  7. Design software prototype with the objective of its maintainability and security. (LO5, LO7).
  8. Design sofware testing methodologies to automatically discover potential security vulnerabilities, such as program crashes (LO6).

Topics Covered

  • Software Development Process
  • Software Design and UML
  • Automated Software Testing: Test Execution and Test Oracle
  • Software Test Design: Blackbox, Whitebox and Fault-based.
  • Web App Testing
  • Software Test Generation and Fuzzing: Blackbox, Greybox and Whitebox
  • Software Secure Coding Patterns for Java
  • Software Code Smells and Refactoring
  • Introduction to Concurrency and Sockets
  • Basics of Threads
  • Thread Safety and Synchronization
  • Composing Thread-safe Objects
  • Building Blocks
  • Tasks and Thread Pools
  • Concurrency Pitfalls and Testing
  • Performance and Patterns; Non-blocking Algorithms

Textbook(s) and/or Other Required Material

  • Brian Goetz et al., Java Concurrency in Practice, 1st ed.  Boston, MA: Addison-Wesley, 2006.

Course Instructor(s)

Prof Kenny LuProf Fredy Tantri

Image Credit (http://wallpaperscraft.com/wallpaper/tablet_smart_phone_hi_tech_icons_hand_96123)