Skip to content
Tutorials Center
My learning

Topics

Software Engineering Tutorial

Learn Software Engineering step by step: 50 lessons in 10 chapters with examples, quizzes, diagrams and projects.

Start learning →

of lessons completed

What Software Engineering Is

  1. 1 What Is Software Engineering? Learn what software engineering is, how it differs from programming, why projects fail, where the field came from and what roles make up a software team.
  2. 2 Qualities of Good Software Learn the main qualities of good software: correctness, reliability, maintainability, performance, security and usability, and how to trade them off.
  3. 3 Software Processes and the Life Cycle Learn the activities every software process contains, the difference between a process and a methodology, and how work flows from idea to maintenance.

The SDLC and Process Models

  1. 4 The Software Development Life Cycle Learn the phases of the software development life cycle, the documents each one produces, and how entry and exit criteria decide when a phase is really done.
  2. 5 The Waterfall Model Learn the waterfall model of software development: sequential phases, its strengths and weaknesses, the cost of late change and where it still fits.
  3. 6 V-Model, Iterative and Incremental Models Learn how the V-model pairs development with testing, how iterative and incremental models differ, and how prototyping reduces risk and delays.
  4. 7 Spiral Model and Risk-Driven Development Learn how the spiral model runs repeated risk analysis loops, uses prototypes to reduce uncertainty, and weighs the cost of reducing a risk against its benefit.
  5. 8 Choosing a Process Model Learn how project size, requirement volatility, regulation, risk and team shape the choice between waterfall, V-model, incremental, spiral, Scrum and Kanban.
  6. 9 Incremental, RAD, Iterative Waterfall, DSDM and Crystal Compare the incremental model, rapid application development (RAD), iterative waterfall, DSDM and Crystal: phases, strengths, weaknesses and when to pick each one.

Requirements Engineering

  1. 10 Gathering Requirements Learn how to find stakeholders and elicit requirements with interviews, surveys, observation and workshops, and how to avoid the classic user-research pitfalls.
  2. 11 Functional and Non-Functional Requirements Learn the difference between functional and non-functional requirements, how to make quality attributes measurable, and how to write requirements you can test.
  3. 12 User Stories, Use Cases and Acceptance Criteria Learn the user story format, the INVEST checklist, how use case scenarios work, and how Given/When/Then acceptance criteria make requirements testable.
  4. 13 The Software Requirements Specification Learn what a Software Requirements Specification contains, how traceability links requirements to tests, how MoSCoW sets priorities and how change control works.

Modeling with UML

  1. 14 UML Overview Learn what UML is for, the difference between structural and behavioral diagrams, and when a quick sketch beats a formal model. Includes a diagram picker.
  2. 15 Use Case Diagrams Learn to read and draw UML use case diagrams: actors, use cases, the system boundary, and the include and extend relationships, with runnable checkers.
  3. 16 Class Diagrams Learn how to read and draw UML class diagrams: attributes, operations, visibility, association, aggregation, composition, inheritance and multiplicity.
  4. 17 Sequence and Activity Diagrams Learn UML sequence diagrams (lifelines, messages, alt and loop fragments) and activity diagrams (flows, decisions, swimlanes), with runnable stand-ins.
  5. 18 State, Component and Deployment Diagrams Learn UML state machine diagrams (states, transitions, guards), component diagrams (interfaces) and deployment diagrams (nodes), with runnable stand-ins.
  6. 19 Data Flow and Entity-Relationship Diagrams Learn data flow diagrams (levels, processes, stores, flows) and entity-relationship diagrams (entities, relationships, cardinality), plus how ER maps to tables.

Software Design

  1. 20 Design Principles: Abstraction, Cohesion and Coupling Learn the core software design principles: abstraction, modularity, information hiding, cohesion, coupling and separation of concerns, with a refactoring example.
  2. 21 Architecture Styles Compare common software architecture styles: layered, client-server, event-driven, pipes and filters, monolith vs services and hexagonal, with trade-offs.
  3. 22 Architecture Decisions and Documentation Learn how to document architecture: decision records (ADRs), the C4 model's four levels, quality attribute scenarios and how to record technical debt trade-offs.
  4. 23 API and Interface Design Learn how to design APIs that last: contracts, backward compatibility, versioning, error design and idempotency, with a runnable contract validator.
  5. 24 Technical Debt and Refactoring Understand technical debt, common code smells and how to refactor safely with tests, plus when a rewrite is justified, with a runnable before and after example.

Agile and Teamwork

  1. 25 Agile Principles and Manifesto Learn why agile arose, what the four values and twelve principles of the Agile Manifesto say, and which common myths about agile are wrong.
  2. 26 Scrum in Practice Learn how Scrum works in practice: the three roles, five events, three artifacts, the definition of done, and the arithmetic behind sprint planning and burndown.
  3. 27 Kanban, Extreme Programming and Lean Learn Kanban boards and WIP limits, Little's Law, the engineering practices of Extreme Programming, and Lean's seven wastes, with simulations you can run.
  4. 28 Estimation and Planning Learn how teams estimate software: story points, planning poker, velocity forecasting, the cone of uncertainty and roadmaps, with runnable calculators.
  5. 29 Working in a Team: Reviews, Communication and Ownership Learn how professional teams work together: code review practice, good pull requests, pair and mob programming, documentation and a blameless culture.

Quality, Testing and Delivery

  1. 30 Testing Levels and Strategy Learn the four testing levels (unit, integration, system, acceptance), the test pyramid, and black-box versus white-box testing, with a tiny runnable test runner.
  2. 31 Test Design Techniques Learn how to choose good test cases: equivalence classes, boundary value analysis, decision tables, state-based tests and coverage, with runnable generators.
  3. 32 TDD and Code Quality Practices Learn the red-green-refactor cycle of test-driven development, what static analysis finds, how cyclomatic complexity is counted, and why code coverage can mislead.
  4. 33 Version Control, CI and Delivery Pipelines Learn how branching strategies, trunk-based development and CI/CD pipeline stages fit together, with read-only Git and pipeline files plus runnable stand-ins.
  5. 34 Deployment, Maintenance and Software Evolution Learn release strategies such as canary and blue-green, how monitoring and incidents work, Lehman's laws of software evolution, legacy systems and end of life.
  6. 35 Software Metrics: Product, Process and People Learn software measurement: product metrics (size, fan-in/fan-out, nesting depth, fog index), process metrics (defect density, lead time) and people metrics, with runnable code.
  7. 36 Coding Standards and Software Documentation Learn why teams adopt coding standards and guidelines, what good ones contain, and how to write useful software documentation for users, developers and operators.

Management, Risk and Professional Practice

  1. 37 Project Management Basics Learn the basics of software project management: the scope-schedule-cost triangle, work breakdown, critical path, Gantt charts and earned value, with runnable calculators.
  2. 38 Risk Management Learn the risk management cycle for software projects: identify, assess, plan responses and monitor, with a risk register, a probability-impact grid and runnable scorers.
  3. 39 Cost Estimation Models Learn software cost estimation models: lines of code versus function points, the basic COCOMO equations, and three-point estimates, with runnable calculators.
  4. 40 Configuration and Change Management Learn baselines, version identifiers, release notes, change requests and semantic versioning, with a JavaScript semver parser, sorter and bumper.
  5. 41 Ethics, Security and Licensing Learn professional ethics, privacy, the secure development life cycle, STRIDE threat modeling and open source license basics, with JavaScript stand-ins.
  6. 42 Product Management for Engineers Learn the product side of software: development stages, value vs effort and Eisenhower matrices, market potential, activation rate, general availability and the project manager's role.

Projects

  1. 43 Project: Design a Library System A guided design project: write requirements and use cases for a library, draw class and sequence diagrams, then code and test the borrowing rules.
  2. 44 Project: An Order Workflow State Machine Design an order life cycle as a state diagram, implement it with a transition table, guards and actions in Node.js, then test it and check it exhaustively.
  3. 45 Project: A Sprint and Velocity Simulator Build a Monte Carlo sprint simulator in JavaScript: a backlog, team capacity, random variation, velocity and a probability-based delivery forecast.
  4. 46 Project: A Requirements Traceability Tool Build a small Node.js tool that links requirements to tests, finds coverage gaps and orphans, prints a report and answers change impact questions.
  5. 47 Project: An Architecture Review and ADR Score three candidate designs against weighted quality scenarios, test how stable the winner is, then record the choice in a validated architecture decision record.

Practice and Interview

  1. 48 Practice Exercises with Solutions Six hands-on software engineering exercises on SDLC costs, requirements, UML checks, design coupling, boundary testing and estimation, each with a runnable solution.
  2. 49 Software Engineering Interview Questions Prepare for software engineering interviews with short, accurate answers on fundamentals, SDLC, agile, UML, design, testing, estimation and behavioral questions.
  3. 50 Software Engineering Cheat Sheet A one-page software engineering cheat sheet: process models, UML diagram picker, requirement and test techniques, design principles, estimation formulas and metrics.