Software Engineering Dependency Graph (SEDG)

Learn Software Engineering From First Principles

Why This Project Exists

Modern software engineering education is fragmented.

Most learning resources are organized around technologies:

• Learn JavaScript
• Learn React
• Learn Node.js
• Learn Docker
• Learn Kubernetes

This approach teaches what to use, but rarely explains why these technologies exist or how they are connected.

As a result, many developers can build applications but struggle to understand the underlying engineering principles.

SEDG exists to solve this problem.

Vision

Create the world's most comprehensive Software Engineering Dependency Graph.

Instead of presenting software engineering as a sequence of tutorials, SEDG models it as a graph of interconnected concepts.

Every concept:

• exists because it solves a problem,
• depends on earlier concepts,
• unlocks future concepts,
• and connects to real-world software systems.

The goal is to help learners build a deep mental model of software engineering rather than memorizing isolated technologies.

Philosophy

SEDG is built around one belief:

Technologies change. Abstractions remain.

Frameworks evolve.

Programming languages evolve.

Cloud platforms evolve.

The fundamental ideas of software engineering remain.

Therefore, learning should begin with abstractions and progress naturally toward technologies.

Learning Philosophy

SEDG is optimized for understanding, not memorization.

Every topic should answer four questions before introducing implementation details.

1. What problem does this solve?
2. Why couldn't previous concepts solve this problem?
3. What new capabilities does this unlock?
4. Where is this used in real software?

Understanding these questions is more valuable than remembering APIs or syntax.

What Makes SEDG Different

SEDG is not:

• another frontend roadmap,
• another backend roadmap,
• another interview guide,
• another collection of tutorials.

SEDG is:

• a dependency graph,
• a knowledge graph,
• a conceptual map of software engineering,
• a long-term educational reference.

Core Principles

1. Understanding Before Memorization

Learners should understand why something exists before learning how to use it.

2. Every Concept Solves a Problem

Nothing appears in the graph without a purpose.

If a concept cannot justify its existence, it should not be included.

3. Every Dependency Is Explicit

Relationships between concepts should never be assumed.

Every edge in the graph must be explainable.

4. Frameworks Are Leaves

Frameworks represent the application of deeper principles.

The graph should always introduce abstractions before frameworks.

5. Knowledge Is Data

Educational content should be represented as structured data.

The visualization is only one way of exploring that data.

Long-Term Goal

SEDG aims to become a complete reference for software engineering knowledge.

Eventually it should support:

• interactive dependency graphs,
• searchable topics,
• multiple learning paths,
• progress tracking,
• AI-assisted tutoring,
• project-based learning,
• printable study guides,
• and community contributions.

Success Criteria

SEDG succeeds if a learner can start with basic programming knowledge and, by following the dependency graph, develop a deep understanding of software engineering—from computer fundamentals to large-scale distributed systems.

The graph should make every new concept feel like a natural consequence of the concepts that came before it.

When a learner reaches an advanced topic such as React Fiber, Docker, Kafka, Kubernetes, or Distributed Systems, they should already understand why those technologies exist because the graph has progressively built the necessary foundations.

Guiding Statement

Software engineering is not a collection of technologies. It is a network of ideas.

SEDG exists to map that network.