Software Engineering 101: Learn the Techniques Behind Developing Good Software

Kurt Anderson, Computer Scientist, Multi-Media Designer

Play Speed
  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x
59 Lessons (5h 38m)
    • 1. Why Use Models

      7:25
    • 2. Software Development Cycle

      6:35
    • 3. Software Cycle Example

      4:38
    • 4. Requirements Definition

      5:53
    • 5. Requirements vs Specifications

      8:23
    • 6. Functional vs Nonfunctional

      7:21
    • 7. WRSPM Model Introduction

      9:52
    • 8. WRSPM Deep Dive

      10:21
    • 9. Requirements Example

      11:17
    • 10. Architecture Introduction

      5:32
    • 11. Architecture Overview and Example

      7:41
    • 12. Pipe and Filter Pattern

      6:35
    • 13. Client-Server Pattern

      4:11
    • 14. Master-Slave Pattern

      4:27
    • 15. Layered Pattern

      5:08
    • 16. Software Engineering Pattern

      9:05
    • 17. Software Design Process

      4:20
    • 18. Stages of Design

      9:27
    • 19. Modularity

      7:00
    • 20. Information Hiding and Data Encapsulation

      7:05
    • 21. Coupling Introduction

      4:32
    • 22. Tight Coupling

      9:55
    • 23. Medium Coupling

      7:25
    • 24. Loose Coupling

      5:39
    • 25. Coupling Conclusion

      2:20
    • 26. Cohesion Introduction

      3:01
    • 27. Weak Cohesion

      7:09
    • 28. Medium Cohesion

      7:54
    • 29. Strong Cohesion

      6:37
    • 30. Importance of Design

      3:36
    • 31. Implementation Basics

      7:46
    • 32. Buy Vs Build

      3:18
    • 33. Deployment Overview

      5:01
    • 34. Deployment Planning

      7:12
    • 35. Deployment Rollback

      3:19
    • 36. Testing Overview

      8:48
    • 37. Testing Bugs

      6:46
    • 38. Verification and Validation

      4:20
    • 39. Unit Testing

      3:05
    • 40. Integration Testing

      3:22
    • 41. Incremental Testing

      10:35
    • 42. Back to Back Testing

      3:50
    • 43. Who Should Test

      5:46
    • 44. Automatic vs Manual Testing

      5:21
    • 45. Black and White Box Testing

      6:23
    • 46. The problem with testing

      3:42
    • 47. Software Development Introduction

      3:35
    • 48. Waterfall Model

      6:03
    • 49. V Model

      5:30
    • 50. Sashimi Model

      4:45
    • 51. Incremental vs Iterative

      4:22
    • 52. Incremental Model

      3:55
    • 53. Unified Process Framework

      10:18
    • 54. Spiral Model

      6:06
    • 55. 60 Agile Introduction

      4:54
    • 56. 61 Agile Manifesto

      8:25
    • 57. 62 Scrum

      7:32
    • 58. 63 Kanban

      9:39
    • 59. 64 Lean Startup

      3:42
21 students are watching this class

About This Class

Building good software takes hard work. It takes planning, design, adjustments, and flexibility to be done properly. Poor decisions during the planning phase can cost hundreds or thousands later on in development. 

In this course, we will be going over the software development life-cycle. We will cover the models, techniques, and planning required to create sustainable code. 

In this course we will be covering:

  • Requirements
  • Specifications
  • Modularity
  • Design
  • Coupling
  • Cohesion
  • Lifecycle Models
  • Waterfall Model
  • Architecture Patterns
  • Iterative Development
  • Incremental Development
  • World Machine Model
  • Testing
  • Testing Perspectives
  • Black and Whitebox Testing