This repository serves as the central documentation for a 52-week intensive software engineering roadmap.
Objective: To transition from AI-dependent development ("Vibe Coding") to fundamental computer science and engineering mastery. Target Date: January 2027.
52-weeks-of-js/
├── 01-iron-foundations/ # Phase 1: Weeks 1-12
│ ├── week-01-js-memory/
│ │ ├── lab/ # Örnek çalışmalar
│ │ ├── notes/ # Notlar
│ │ └── README.md # Haftalık özet
│ ├── week-02-scope/
│ └── ...
├── 02-web-architecture/ # Phase 2: Weeks 13-28
├── 03-universal-ecosystem/ # Phase 3: Weeks 29-40
├── 04-seniority-cs/ # Phase 4: Weeks 41-52
├── resources/
│ ├── books.md # Okunan kaynaklar
│ └── tools.md # Kullanılan araçlar
└── README.md # Bu dosya
- No AI for Logic: Artificial Intelligence tools are strictly prohibited for generating solution logic or writing code. They may only be used for explanation or debugging after a solution has been attempted.
- First Principles: The focus is not on "how" to use a framework, but "why" it works and how it is constructed at the source code level.
- Deep Dives: Every topic is explored until the underlying mechanism (memory, network, OS interaction) is understood.
Focus: JavaScript Runtime, Node.js Internals, Data Structures, and Raw SQL. Goal: Understanding how code interacts with the machine's memory and processor without abstraction layers.
- Week 01: JS Memory Management & Runtime
- Topics: Stack vs Heap, Reference Types, Garbage Collection algorithms (Mark and Sweep), Memory Leaks.
- Goal: To visualize physical memory allocation when writing code.
- Week 02: Scope & Closures
- Topics: Lexical Environment, Hoisting, IIFE, Module Pattern, Closure memory costs.
- Goal: To master variable lifecycles and encapsulation.
- Week 03: Async JavaScript Deep Dive
- Topics: Event Loop architecture, Macrotasks vs Microtasks, Callback Queues, Promise internals, async/await compilation.
- Goal: To manage concurrency and non-blocking I/O effectively.
- Week 04: Object-Oriented JS & Prototypes
- Topics: The 'this' keyword rules, Prototype Chain, Class Inheritance vs Composition, Factory Functions.
- Goal: To understand JavaScript's unique inheritance model compared to classical OOP.
- Week 05: Advanced TypeScript I
- Topics: Interfaces vs Types, Enums, Union/Intersection Types, Tuples, Unknown vs Any.
- Goal: To enforce strict type safety and reduce runtime errors.
- Week 06: Advanced TypeScript II
- Topics: Generics, Utility Types (Partial, Pick, Omit, Record), Type Guards, Conditional Types, Infer.
- Goal: To write reusable and robust type definitions for complex data.
- Week 07: Node.js Internals
- Topics: V8 Engine architecture, Libuv, Single Thread nature, Thread Pool, Event Loop phases.
- Goal: To understand the limitations and strengths of the Node.js runtime.
- Week 08: Raw Backend Engineering
- Topics: No-Framework Node.js, 'http' module, Streams, Buffers, Chunked Transfer Encoding.
- Goal: To build efficient servers without the overhead of Express or NestJS.
- Week 09: Data Structures I
- Topics: Big O Notation (Time/Space Complexity), Manual implementation of Arrays and Linked Lists.
- Goal: To understand the performance cost of data storage choices.
- Week 10: SQL & Relational Theory
- Topics: ACID Properties, Raw SQL Queries (SELECT, JOIN, GROUP BY), PostgreSQL setup without ORM.
- Goal: To master data manipulation language (DML) directly.
- Week 11: Database Indexing & Performance
- Topics: B-Tree data structures, Clustered vs Non-Clustered Indexes, Query Execution Plans.
- Goal: To optimize database performance at the architectural level.
- Week 12: Application Architecture: CLI Tools
- Topics: Command-line logic, File System (fs) module, Process arguments, Stream piping.
- Goal: To build a complete logic-heavy application without a graphical interface.
Focus: React Internals, Next.js Architecture, Testing, CI/CD, and Security. Goal: Mastering the source code and architectural decisions of the modern web stack.
- Week 13: React Internals
- Topics: Virtual DOM, Reconciliation Algorithm (Diffing), Fiber Architecture, Render Cycle.
- Goal: To optimize rendering performance by understanding the React engine.
- Week 14: Advanced Hooks & Performance
- Topics: useMemo, useCallback, Referential Equality, Custom Hooks design patterns.
- Goal: To prevent unnecessary re-renders and memory waste.
- Week 15: State Management Patterns
- Topics: Flux Architecture, Observer Pattern, Proxy Pattern (Zustand logic), Context API limitations.
- Goal: To manage complex application state without prop-drilling.
- Week 16: Component Design Patterns
- Topics: Higher Order Components (HOC), Compound Components, Render Props.
- Goal: To create reusable and maintainable component libraries.
- Week 17: Rendering Architectures
- Topics: SSR, CSR, SSG, ISR concepts, Server Cost vs Client Performance analysis.
- Goal: To choose the correct rendering strategy for different use cases.
- Week 18: Next.js Internals
- Topics: App Router architecture, React Server Components (RSC), Network Boundary.
- Goal: To leverage server-side capabilities within the React ecosystem.
- Week 19: API Design Standards
- Topics: REST vs GraphQL, HTTP Methods, Idempotency, Status Codes, API Versioning.
- Goal: To design predictable and standard-compliant APIs.
- Week 20: Authentication & Security Theory
- Topics: OAuth 2.0, OpenID Connect, JWT vs Session Auth, Secure Token Storage (HttpOnly Cookies).
- Goal: To implement secure identity management.
- Week 21: Testing Methodologies
- Topics: The Test Pyramid, Unit vs Integration vs E2E Testing, Mocking, Stubbing.
- Goal: To ensure software reliability through automated verification.
- Week 22: Containerization (Docker)
- Topics: OS-level virtualization, Docker Images, Layers, Networking, Volumes, Dockerfiles.
- Goal: To create consistent development and production environments.
- Week 23: CI/CD Pipelines
- Topics: Continuous Integration principles, GitHub Actions, Build Pipelines, Automated Testing.
- Goal: To automate the software delivery lifecycle.
- Week 24: Web Security (OWASP)
- Topics: XSS, CSRF, SQL Injection, Security Headers (CSP), Rate Limiting.
- Goal: To proactively harden applications against common vulnerabilities.
- Week 25: Mobile Runtime Environment
- Topics: React Native Bridge, Threading Model (JS vs UI vs Native), The New Architecture (JSI, Fabric).
- Goal: To understand how JavaScript drives native mobile UI.
- Week 26: Mobile UI Architecture
- Topics: Yoga Layout Engine, Flexbox differences on Mobile, Native UI Components.
- Goal: To build performant mobile interfaces.
- Week 27: Native Modules Logic
- Topics: Bridging JavaScript to Native iOS (Obj-C/Swift) and Android (Java/Kotlin) APIs.
- Goal: To access device capabilities not available in the standard runtime.
- Week 28: Offline Data Strategy
- Topics: Local Storage engines (SQLite/Realm), Synchronization logic, Conflict Resolution.
- Goal: To build "Offline-First" applications.
Focus: Cross-Platform Development and Distributed Systems Basics. Goal: Running code efficiently across Mobile, Desktop, and Server environments.
- Week 29: Desktop Architecture (Electron)
- Topics: Chromium & Node.js integration, Main Process vs Renderer Process, IPC Communication.
- Goal: To port web logic to desktop environments securely.
- Week 30: OS Integration
- Topics: File System Access, System Tray integration, Native OS Notifications.
- Goal: To build applications that feel native to the operating system.
- Week 31: Monorepo Tooling
- Topics: Workspaces, Dependency Graphs, Code Sharing Strategies, Tools (Turborepo/Nx).
- Goal: To manage large-scale codebases with shared libraries.
- Week 32: Network Protocols
- Topics: TCP vs UDP, WebSockets (Handshake, Frames), Server-Sent Events (SSE).
- Goal: To implement real-time communication protocols.
- Week 33: Caching Strategies
- Topics: Cache-Aside, Write-Through, Write-Back, Redis Data Structures.
- Goal: To reduce database load and improve latency.
- Week 34: Message Brokers
- Topics: Publisher/Subscriber Model, Message Queues (RabbitMQ/Kafka basics), Async Job Processing.
- Goal: To decouple system components and handle background tasks.
- Week 35: Distributed Systems I
- Topics: CAP Theorem (Consistency, Availability, Partition Tolerance), Eventual Consistency.
- Goal: To understand the trade-offs in distributed data systems.
- Week 36: Distributed Systems II
- Topics: Load Balancing Algorithms (Round Robin, Least Connections), Horizontal vs Vertical Scaling.
- Goal: To design systems that can handle increased traffic load.
- Week 37: Data Structures II (Trees)
- Topics: Binary Search Trees (BST), AVL Trees, Tree Traversal (BFS/DFS).
- Goal: To solve hierarchical data problems efficiently.
- Week 38: Data Structures III (Graphs)
- Topics: Adjacency Matrix vs List, Shortest Path Algorithms (Dijkstra), Network flow.
- Goal: To solve complex relationship and routing problems.
- Week 39: Algorithm Patterns I
- Topics: Dynamic Programming (Memoization, Tabulation), Recursion limits.
- Goal: To optimize recursive solutions for time complexity.
- Week 40: Algorithm Patterns II
- Topics: Greedy Algorithms, Backtracking.
- Goal: To solve optimization and constraint satisfaction problems.
Focus: System Design, Advanced Algorithms, and Engineering Career. Goal: Developing the ability to design large-scale systems and demonstrate senior-level competency.
- Week 41: System Design: Scalability
- Topics: Database Sharding, Partitioning strategies, Replication (Master-Slave).
- Goal: To design data layers that scale horizontally.
- Week 42: System Design: Microservices
- Topics: API Gateway pattern, Service Discovery, Circuit Breakers, Inter-service communication.
- Goal: To architect decoupled and resilient systems.
- Week 43: System Design: Data Modeling
- Topics: NoSQL (Document, Columnar) vs SQL selection criteria, Data normalization vs denormalization.
- Goal: To choose the right storage technology for specific data patterns.
- Week 44: Web Performance Engineering
- Topics: Critical Rendering Path analysis, Browser Painting, Bundle Optimization, Tree Shaking.
- Goal: To achieve maximum runtime performance on the client side.
- Week 45: LeetCode Practice (Arrays/Strings)
- Topics: Optimization problems using Sliding Window and Two Pointer techniques.
- Goal: To prepare for algorithmic problem solving under constraints.
- Week 46: LeetCode Practice (LinkedLists/Trees)
- Topics: Pointer manipulation, Inverting trees, Level-order traversal.
- Goal: To master non-contiguous data structures.
- Week 47: LeetCode Practice (DP/Graphs)
- Topics: Complex dynamic programming and graph traversal problems.
- Goal: To solve the most challenging class of interview problems.
- Week 48: Code Review Discipline
- Topics: SOLID Principles, DRY, KISS, Refactoring techniques, Code Smells.
- Goal: To write maintainable code and conduct effective peer reviews.
- Week 49: Open Source Contribution Theory
- Topics: Reading large codebases, Understanding contribution guidelines, Pull Request etiquette.
- Goal: To learn how to collaborate on global-scale software.
- Week 50: Technical Documentation
- Topics: Writing technical specifications, Architecture Decision Records (ADR), API documentation.
- Goal: To communicate complex technical concepts clearly.
- Week 51: Career & Interview Preparation
- Topics: System Design whiteboard simulations, Behavioral competency, Technical storytelling.
- Goal: To effectively demonstrate engineering expertise.
- Week 52: Retrospective & Graduation
- Topics: Review of the 52-week journey, Analysis of learned concepts, Future specialization planning.
- Goal: To conclude the roadmap and transition to the next career phase.