Bientôt disponible
Software Engineering
Écrivez du code auquel votre équipe fait confiance. Livrez des systèmes qui tiennent.
Le cours complet
- modules
- 62
- thèmes
- 651
- min par leçon
- 15
86%
des employeurs attendent de l'IA et du traitement de l'information qu'ils transforment leur activité d'ici 2030.
Ce que vous saurez faire.
Lisez et déboguez du code que vous n'avez pas écrit
Étape 1 · Programming Foundations
Transformez des demandes floues en exigences claires
Étape 2 · Requirements & Design
Modélisez les données et gardez-les cohérentes
Étape 3 · Data & Distributed Systems
Écrivez des tests, de l'unitaire au bout en bout
Étape 4 · Security & Testing
Déployez via CI/CD et gérez les incidents
Étape 5 · Delivery & Operations
Menez un produit de la spec à la mise en production
Étape 7 · Integrated Projects
Sept étapes.Une ascension continue.
Tout ce qu'il y a entre écrire du code et faire tourner un logiciel dont on dépend.
62modules
en 7 étapes
651thèmes
≈ 11 par module
≈163heures
en leçons de 15 minutes
≈21mois
≈11mois
≈5mois
pour finir tout le cours
- 1
Programming Foundations
Comment le code tourne, plante et se répare
14 modules · 145 thèmes · ≈ 36 h
- 2
Requirements & Design
Quoi construire, et comment le concevoir
12 modules · 127 thèmes · ≈ 32 h
- 3
Data & Distributed Systems
Des données justes sur toutes les machines
10 modules · 107 thèmes · ≈ 27 h
- 4
Security & Testing
La preuve que ça marche, et reste sûr
11 modules · 115 thèmes · ≈ 29 h
- 5
Delivery & Operations
Du merge à la prod, astreinte comprise
8 modules · 86 thèmes · ≈ 22 h
- 6
Professional Practice
Le travail en équipe, au quotidien
6 modules · 61 thèmes · ≈ 15 h
- 7
Integrated Projects
Dix projets, du début à la fin
1 module · 10 thèmes · ≈ 3 h
Mois
04812160246801234
MoisArrivée · ≈ 21 mois · ≈ 11 mois · ≈ 5 mois
Heures et mois sont des estimations : une leçon de 15 minutes par thème, chaque jour.
Chaque module.Chaque thème.
Les titres des modules et des thèmes restent en anglais, la langue du secteur.
Étape 1
Programming Foundations
Comment le code tourne, plante et se répare
14 modules · 145 thèmes
1The World of Software Engineering9 thèmes
- What Software Engineers Actually Build
- Programming vs. Software Engineering
- Software as a Product, Service, and Component
- Correctness, Usefulness, and Fitness for Purpose
- Complexity and the Cost of Change
- Engineering Decisions Under Constraints
- The Responsibilities of a Software Engineer
- Working Across Product, Design, Engineering, and Operations
- The Full Lifetime of a Software System
2Software Systems and Their Life Cycles10 thèmes
- Programs, Applications, Services, and Platforms
- System Boundaries and External Dependencies
- Users, Operators, and Other Stakeholders
- From an Idea to a Running Software System
- Discovery, Development, Delivery, and Maintenance
- Prototypes, Experiments, and Production Systems
- Iterative and Incremental Development
- Predictive, Adaptive, and Hybrid Life Cycles
- Feedback Loops Across the Software Life Cycle
- Retirement and Replacement as Engineering Activities
3Computational Problem Solving10 thèmes
- Turning a Problem into Inputs, Outputs, and Rules
- Decomposition and Stepwise Refinement
- Abstraction and Essential Detail
- Boolean Logic and Compound Conditions
- Sets, Relations, and Mappings
- States, Transitions, and Invariants
- Examples, Counterexamples, and Edge Cases
- Pseudocode and Algorithm Sketches
- Estimation and Reasonableness Checks
- Distinguishing a Correct Solution from a Practical One
4Programs, Languages, and Execution10 thèmes
- Source Code and Executable Behavior
- Syntax, Semantics, and Program Meaning
- Compiled, Interpreted, and Hybrid Execution
- Runtimes, Virtual Machines, and Standard Libraries
- Entry Points and Program Startup
- Expressions, Statements, and Evaluation
- Scope, Namespaces, and Name Resolution
- The Call Stack and Function Execution
- Input, Output, and Interaction with the Environment
- Choosing a Language for Constraints and Team Capabilities
5Values, Types, and Data Representation12 thèmes
- Variables, Values, and Bindings
- Integers, Floating-Point Numbers, and Precision
- Booleans and Logical Values
- Strings, Unicode, and Text Encoding
- Records, Objects, and Structured Values
- Enumerations and Explicit State Representation
- Static and Dynamic Type Checking
- Type Inference and Type Conversion
- Null, Missing Values, and Optional Types
- Equality, Identity, and Comparison
- Dates, Times, Time Zones, and Durations
- Representing Money, Units, and Domain-Specific Quantities
6Control Flow and Functions11 thèmes
- Conditional Execution and Branching
- Loops and Iteration
- Early Returns and Guard Clauses
- Functions, Parameters, and Return Values
- Function Contracts and Caller Expectations
- Passing Values and References
- Recursion and Base Cases
- Higher-Order Functions and Callbacks
- Closures and Captured State
- Separating Calculation from Side Effects
- Keeping Control Flow Understandable
7Practical Data Structures10 thèmes
- Arrays and Dynamic Arrays
- Linked Structures and Their Trade-Offs
- Stacks and Queues
- Maps, Dictionaries, and Hash Tables
- Sets and Membership Tests
- Trees and Hierarchical Data
- Graphs and Connected Data
- Heaps and Priority Queues
- Iterators and Collection Traversal
- Choosing Structures by Operations and Constraints
8Algorithms and Computational Cost12 thèmes
- Algorithm Correctness and Termination
- Linear Search and Binary Search
- Sorting and Ordering Requirements
- Traversing Trees and Graphs
- Recursion vs. Iteration
- Divide-and-Conquer Strategies
- Greedy Decisions and Their Limitations
- Reusing Results with Memoization
- Time and Space Complexity
- Big-O Notation and Its Practical Limits
- Input Size, Constant Factors, and Real Workloads
- Recognizing When an Algorithm Needs to Change
9State, Mutation, and Resource Management10 thèmes
- Local State and Shared State
- Mutable and Immutable Data
- Aliasing and Unexpected Changes
- Object Lifetimes and Resource Ownership
- Stack and Heap Allocation as Programming Concepts
- Garbage Collection and Managed Memory
- Explicit Cleanup and Scoped Resource Management
- Files, Connections, and Other Finite Resources
- Copying, Sharing, and Defensive Boundaries
- Preventing Resource Leaks and Unbounded Growth
10Errors, Failures, and Defensive Programming10 thèmes
- Invalid Inputs, Programming Defects, and Operational Failures
- Exceptions, Error Values, and Result Types
- Validation at System Boundaries
- Recoverable and Unrecoverable Conditions
- Preserving Error Context
- Error Propagation and Translation
- Cleanup When Operations Fail
- Assertions and Internal Consistency Checks
- Avoiding Silent Failure and Misleading Success
- Designing Useful Error Messages
11The Development Environment9 thèmes
- Editors, IDEs, and Language Tooling
- Terminals, Shells, and Command-Line Programs
- Project Structure and Repository Layout
- Installing and Selecting Toolchain Versions
- Running Programs and Automated Checks Locally
- Configuration Files and Environment Variables
- Formatters, Linters, and Static Checks
- Debuggers and Interactive Inspection
- Reproducible Setup for a New Contributor
12Reading and Debugging Code11 thèmes
- Finding Entry Points and Following Execution
- Reading Unfamiliar Functions and Modules
- Understanding Tests as Behavioral Examples
- Reproducing a Defect Reliably
- Reducing a Problem to a Minimal Example
- Breakpoints, Stepping, and Variable Inspection
- Reading Stack Traces and Error Reports
- Forming and Testing Debugging Hypotheses
- Finding the First Incorrect State
- Separating Symptoms from Root Causes
- Adding a Regression Test After a Fix
13Version Control and Collaborative Changes11 thèmes
- Repositories, Commits, and Change History
- Working Trees, Staging, and Diffs
- Writing Focused Commits
- Branches and Parallel Work
- Merging and Rebasing as Different History Operations
- Resolving Conflicts with Behavioral Checks
- Pull Requests and Reviewable Change Sets
- Trunk-Based and Branch-Based Workflows
- Tags and Release References
- Reverting Changes and Recovering Safely
- Using History and Bisection to Investigate Defects
14Dependencies, Packages, and Configuration10 thèmes
- Direct and Transitive Dependencies
- Package Manifests and Lockfiles
- Version Constraints and Reproducible Resolution
- Evaluating a Library Before Adoption
- Dependency Updates and Compatibility Checks
- Separating Application Configuration from Code
- Validating Configuration at Startup
- Handling Secrets Outside Source Control
- Dependency Provenance and Supply-Chain Exposure
- Removing Unused and Abandoned Dependencies
Étape 2
Requirements & Design
Quoi construire, et comment le concevoir
12 modules · 127 thèmes
15Understanding Problems and Stakeholders10 thèmes
- Starting with a Problem Rather Than a Feature
- Identifying Users and Other Affected Groups
- Understanding Existing Workflows
- Interviews, Observation, and Evidence Gathering
- Separating Stated Requests from Underlying Needs
- Stakeholder Conflicts and Competing Priorities
- Current-State and Desired-State Descriptions
- Assumptions, Unknowns, and Open Questions
- Defining Outcomes and Success Criteria
- Deciding Whether Software Is the Right Intervention
16Requirements Specification and Validation11 thèmes
- Functional Requirements and Business Rules
- User Stories and Use Cases
- Acceptance Criteria and Concrete Examples
- Preconditions, Postconditions, and Exceptional Cases
- Writing Clear and Testable Requirements
- Ambiguity, Inconsistency, and Missing Behavior
- Prioritizing Requirements and Defining Scope
- Prototypes as Requirements-Discovery Tools
- Requirements Reviews with Stakeholders
- Traceability from Need to Implementation and Test
- Managing Requirement Changes and Their Impact
17Quality Attributes and Engineering Constraints11 thèmes
- Functional Correctness vs. Quality of Service
- Reliability and Availability Requirements
- Performance, Latency, and Throughput
- Scalability and Capacity Expectations
- Security and Privacy Requirements
- Maintainability, Modifiability, and Testability
- Usability and Accessibility
- Compatibility and Portability
- Cost, Schedule, and Resource Constraints
- Writing Measurable Quality-Attribute Scenarios
- Resolving Trade-Offs Between Quality Goals
18Modeling Domains and Workflows10 thèmes
- Shared Vocabulary and Domain Concepts
- Actors, Roles, and System Interactions
- Entities, Values, and Relationships
- Business Rules and Domain Invariants
- State Machines and Lifecycle Models
- Activity Flows and Decision Points
- Sequence Diagrams and Interaction Scenarios
- Context Boundaries and Different Meanings of the Same Term
- Modeling Exceptions and Alternative Paths
- Keeping Models Useful as the System Changes
19Planning Incremental Delivery10 thèmes
- Turning Requirements into Small Deliverable Slices
- Vertical Slices vs. Technical-Layer Tasks
- Prioritizing by Value, Risk, and Dependency
- Discovery Work and Time-Bounded Technical Spikes
- Minimum Useful Releases
- Making Work Ready for Implementation
- Defining What Done Means
- Handling Uncertainty in Estimates
- Limiting Work in Progress
- Reviewing Outcomes and Replanning from Evidence
20Readable and Maintainable Code11 thèmes
- Names That Express Intent
- Small, Cohesive Functions
- Clear Control Flow and Limited Nesting
- Consistent Conventions and Formatting
- Comments That Explain Decisions and Constraints
- Removing Dead Code and Misleading Abstractions
- Duplication vs. Premature Generalization
- Explicit Dependencies and Predictable Behavior
- Separating Domain Rules from Technical Plumbing
- Local Reasoning and Reducing Cognitive Load
- Recognizing Code Smells Without Treating Them as Proof
21Modular Design and Interfaces11 thèmes
- Modules as Units of Responsibility
- Cohesion and Coupling
- Information Hiding and Encapsulation
- Public Contracts and Private Implementation
- Abstract Data Types
- Dependency Direction and Dependency Inversion
- Composition and Replaceable Components
- Designing Stable Module Boundaries
- Avoiding Cyclic Dependencies
- Balancing Reuse with Independent Change
- Testing Modules Through Their Contracts
22Programming Paradigms and Design Choices11 thèmes
- Procedural Decomposition
- Object-Oriented Modeling
- Objects, Responsibilities, and Collaboration
- Inheritance and Substitutability
- Composition vs. Inheritance
- Functional Decomposition and Pure Functions
- Immutability and Transformation Pipelines
- Declarative vs. Imperative Code
- Generic Programming and Reusable Abstractions
- Combining Paradigms Within One System
- Choosing a Paradigm for the Problem, Not the Fashion
23Design Patterns and Their Trade-Offs10 thèmes
- Patterns as Reusable Design Ideas
- Strategy and Interchangeable Behavior
- Adapter and Boundary Translation
- Factory and Controlled Object Creation
- Decorator and Composable Responsibilities
- Observer and Change Notification
- Command and Explicit Operations
- State and Behavior Across Lifecycle Stages
- Dependency Injection and the Composition Root
- Pattern Overuse and Accidental Complexity
24Software Architecture Fundamentals11 thèmes
- Architecture as High-Impact Design Decisions
- System Context and Architectural Boundaries
- Components, Connectors, and Responsibilities
- Static Structure and Runtime Behavior
- Deployment Views and Execution Environments
- Quality Attributes as Architectural Drivers
- Architectural Constraints and Assumptions
- Trade-Off Analysis and Risk Identification
- Architecture Decision Records
- Prototypes for Testing Architectural Assumptions
- Architecture Evaluation and Evolution
25Architectural Styles and System Boundaries10 thèmes
- Layered Architecture
- Modular Monoliths
- Client-Server Systems
- Ports and Adapters
- Event-Driven Architecture
- Service-Oriented Decomposition
- Microservices and Their Coordination Costs
- Data-Centered and Pipeline Architectures
- Synchronous vs. Asynchronous Boundaries
- Choosing the Simplest Architecture That Meets the Requirements
26API Design and Contracts11 thèmes
- APIs as Agreements Between Components
- Resource-Oriented and Operation-Oriented Interfaces
- Naming, Consistency, and Discoverability
- Request and Response Models
- Validation Rules and Error Contracts
- Pagination, Filtering, and Sorting
- Idempotent Operations and Retry-Safe Contracts
- Versioning and Backward Compatibility
- API Schemas and Machine-Readable Descriptions
- Public, Partner, and Internal APIs
- Designing Interfaces for Real Consumer Workflows
Étape 3
Data & Distributed Systems
Des données justes sur toutes les machines
10 modules · 107 thèmes
27Application Data Modeling10 thèmes
- Translating Domain Concepts into Stored Data
- Identity, Keys, and Relationships
- Required, Optional, and Derived Values
- Enforcing Data Invariants
- Normalization and Intentional Denormalization
- Historical Records and Changing Business Facts
- Modeling Status, Ownership, and Lifecycle
- Separating Internal Models from External Representations
- Schema Evolution and Migration Planning
- Avoiding Data Models That Encode Accidental Assumptions
28Relational Persistence and Querying11 thèmes
- Tables, Rows, and Relational Structure
- Creating, Reading, Updating, and Deleting Records
- Selecting, Filtering, and Ordering Data
- Joins and Relationship Traversal
- Aggregation and Grouping
- Constraints and Referential Integrity
- Parameterized Queries
- Indexes and Query-Access Patterns
- Object-Relational Mapping and Its Trade-Offs
- Connection Management and Query Boundaries
- Diagnosing Excessive Queries and Inefficient Data Access
29Files, Formats, and Alternative Storage10 thèmes
- Text and Binary Data Formats
- Serialization and Deserialization
- Schema Validation and Format Compatibility
- Safe File Paths and File Operations
- Streaming Data vs. Loading Everything into Memory
- Document Stores and Aggregate-Oriented Data
- Key-Value Stores and Simple Access Patterns
- Object Storage for Files and Large Blobs
- Embedded Storage and Local Application State
- Choosing Storage by Access, Consistency, and Operational Needs
30Transactions and Data Consistency11 thèmes
- Atomicity, Consistency, Isolation, and Durability
- Transaction Boundaries and Business Operations
- Read and Write Anomalies
- Isolation Levels and Their Trade-Offs
- Optimistic and Pessimistic Concurrency Control
- Lost Updates and Concurrent Modification
- Constraints as a Last Line of Defense
- Commit, Rollback, and Failure Recovery
- Handling Duplicate Requests and Repeated Effects
- Coordinating Database Changes with External Side Effects
- Testing Consistency Under Concurrent Access
31Concurrency Within an Application11 thèmes
- Concurrency vs. Parallelism
- Processes, Threads, and Tasks
- Shared Memory and Message Passing
- Race Conditions and Nondeterministic Behavior
- Atomicity and Visibility of Changes
- Locks, Mutexes, and Critical Sections
- Deadlock, Livelock, and Starvation
- Thread-Safe Data Structures
- Immutable Data and Ownership-Based Designs
- Cancellation and Task Lifetimes
- Testing Concurrent Code and Its Interleavings
32Networked Applications11 thèmes
- Clients, Servers, and Request Lifecycles
- Addresses, Ports, and Name Resolution
- Connections, Streams, and Message Boundaries
- HTTP Methods, Status Codes, and Headers
- Stateless Requests and Stateful Sessions
- TLS and Secure Transport as Application Requirements
- Timeouts, Connection Failures, and Partial Responses
- Connection Pools and Resource Limits
- Proxies, Gateways, and Load Balancers
- Network Latency and the Cost of Remote Calls
- Diagnosing Application-Level Network Failures
33Asynchronous Work and Background Processing11 thèmes
- Blocking and Nonblocking Work
- Futures, Promises, and Asynchronous Results
- Event Loops and Task Scheduling
- Queues and Background Workers
- Job State and Progress Reporting
- Retries, Backoff, and Retry Limits
- Duplicate Delivery and Idempotent Handlers
- Ordering Requirements and Parallel Workers
- Backpressure and Bounded Queues
- Dead-Letter Handling and Failed-Job Recovery
- Cancellation, Shutdown, and Unfinished Work
34Distributed Application Design11 thèmes
- Why Remote Components Fail Independently
- Partial Failure and Uncertain Outcomes
- Replication and Multiple Copies of State
- Strong and Eventual Consistency
- Consistency and Availability During Network Partitions
- Ordering, Clocks, and Causality
- Delivery Guarantees vs. Processing Effects
- Coordinating Work Across Service Boundaries
- Sagas and Compensating Actions
- Transactional Outbox and Reliable Event Publication
- Choosing What Must Be Distributed and What Should Stay Together
35User Interfaces and Interaction Engineering11 thèmes
- Connecting User Tasks to Interface Behavior
- Separating Presentation from Domain Logic
- UI State and State Transitions
- Forms, Validation, and Error Recovery
- Loading, Empty, Success, and Failure States
- Responsive Behavior Across Devices
- Semantic Structure and Assistive Technology
- Keyboard Navigation and Focus Management
- Localization, Text Direction, and Locale-Sensitive Data
- Optimistic Updates and Their Failure Cases
- Testing Usability and Accessibility with Real Workflows
36Integrating External Services10 thèmes
- Evaluating an External API or SDK
- Translating External Models at System Boundaries
- Credentials, Permissions, and Service Configuration
- Rate Limits and Usage Quotas
- Webhooks and Incoming Event Validation
- Handling Provider Outages and Degraded Responses
- Sandboxes, Test Accounts, and Contract Differences
- Avoiding Duplicate External Actions
- Monitoring Integration Health and Cost
- Provider Changes, Fallbacks, and Exit Strategies
Étape 4
Security & Testing
La preuve que ça marche, et reste sûr
11 modules · 115 thèmes
37Secure Software Construction12 thèmes
- Trust Boundaries and Untrusted Inputs
- Secure Defaults and Least Privilege
- Threat Modeling for a Feature or Service
- Input Validation vs. Output Encoding
- Preventing Injection with Safe Interfaces
- Safe Handling of Files, Uploads, and Paths
- Protecting State-Changing Requests
- Restricting Server-Side Requests and External Destinations
- Secrets Handling and Safe Logging
- Dependency Vulnerabilities and Remediation
- Security Tests in the Development Workflow
- Responding to a Reported Vulnerability
38Identity, Authentication, and Authorization10 thèmes
- Identity, Authentication, and Authorization as Separate Concerns
- Users, Service Accounts, and Machine Identities
- Sessions, Tokens, and Credential Lifetimes
- Integrating Established Identity Providers
- Password Handling with Established Security Libraries
- Roles, Permissions, and Policy-Based Access
- Object-Level and Tenant-Level Authorization
- Enforcing Access Checks on the Trusted Side
- Account Recovery, Revocation, and Logout Behavior
- Auditing Sensitive Actions and Permission Changes
39Privacy and the Data Life Cycle10 thèmes
- Identifying Personal and Sensitive Data
- Data Minimization and Purpose Boundaries
- Mapping Where Data Enters, Moves, and Leaves
- Retention, Deletion, and Backup Implications
- Redaction and Safe Diagnostic Data
- Pseudonymization vs. Anonymization
- Privacy-Preserving Test Data
- Designing User Controls for Data Access and Export
- Preventing Cross-Tenant Data Exposure
- Translating Privacy Obligations into Engineering Requirements
40Test Strategy and Test Design11 thèmes
- Verification vs. Validation
- Testing as Evidence Rather Than Proof of Perfection
- Risk-Based Test Prioritization
- Unit, Integration, System, and Acceptance Tests
- Example-Based Test Design
- Equivalence Classes and Boundary Values
- Decision Tables and State-Transition Tests
- Happy Paths, Failure Paths, and Recovery Paths
- Test Data and Environment Control
- Balancing Test Speed, Fidelity, and Maintenance Cost
- Defining a Test Strategy for a Specific System
41Unit Testing and Testable Design11 thèmes
- Testing a Small Unit Through Observable Behavior
- Arrange, Act, and Assert
- Naming Tests as Behavioral Statements
- Independent and Deterministic Tests
- Stubs, Fakes, Mocks, and Spies
- Controlling Time, Randomness, and External Dependencies
- Testing Errors and Exceptional Conditions
- Parameterized Tests
- Property-Based Testing
- Test-Driven Development and Its Trade-Offs
- Avoiding Tests That Mirror the Implementation
42Integration, Contract, and End-to-End Testing11 thèmes
- Testing Collaborating Components
- Integration Tests with Real Persistence
- Contract Tests Between Producers and Consumers
- API-Level Functional Tests
- End-to-End User Journeys
- Test Environments and Representative Configuration
- Fixtures, Seed Data, and Cleanup
- Testing Background Work and Eventual Outcomes
- Detecting and Controlling Flaky Tests
- Interpreting Failures Across Multiple System Layers
- Keeping Broad Tests Focused on High-Value Behavior
43Testing Quality Attributes10 thèmes
- Load, Stress, and Endurance Tests
- Measuring Latency Distributions and Throughput
- Capacity Limits and Saturation Behavior
- Reliability and Recovery Tests
- Fault Injection in Controlled Environments
- Security and Authorization Tests
- Accessibility and Compatibility Tests
- Migration and Data-Integrity Tests
- Establishing Baselines and Detecting Regressions
- Distinguishing Laboratory Results from Production Guarantees
44Diagnosing Complex Failures10 thèmes
- Reconstructing a Failure from Incomplete Evidence
- Correlating Logs, Metrics, and Traces
- Separating Code, Data, Configuration, and Environment Causes
- Reproducing Production Conditions Safely
- Investigating Intermittent and Timing-Dependent Defects
- Diagnosing Memory Leaks and Resource Exhaustion
- Finding Bottlenecks with Profilers
- Investigating Recent Changes with Controlled Comparisons
- Testing a Root-Cause Explanation Against the Evidence
- Verifying a Fix Beyond the Original Failure Case
45Refactoring and Technical Debt11 thèmes
- Refactoring vs. Changing Behavior
- Establishing a Safety Net Before Restructuring
- Extracting Functions and Modules
- Simplifying Conditional Logic
- Improving Names and Data Structures
- Removing Duplication Without Premature Abstraction
- Introducing Seams Around Difficult Dependencies
- Recognizing Architectural and Operational Debt
- Intentional Trade-Offs vs. Uncontrolled Deterioration
- Prioritizing Debt by Risk and Change Cost
- Refactoring Incrementally While Continuing Delivery
46Reasoning About Correctness9 thèmes
- Specifications as Statements of Required Behavior
- Preconditions and Postconditions
- Representation Invariants
- Loop Invariants and Termination Arguments
- State Machines and Invalid Transitions
- Making Invalid States Harder to Represent
- Refinement from Abstract Rules to Concrete Code
- Model Checking as a Verification Technique
- What Formal Reasoning Can and Cannot Guarantee
47Code Review and Static Quality Checks10 thèmes
- Reviewing for Correctness, Clarity, and Maintainability
- Preparing a Change for Efficient Review
- Distinguishing Blocking Issues from Preferences
- Reviewing Tests Alongside Implementation
- Checking Error Handling and Failure Behavior
- Reviewing Security and Data-Handling Boundaries
- Automated Formatting and Linting
- Type Checking and Static Analysis
- Interpreting Warnings and False Positives
- Giving Actionable Feedback and Resolving Disagreements
Étape 5
Delivery & Operations
Du merge à la prod, astreinte comprise
8 modules · 86 thèmes
48Build Systems and Software Artifacts10 thèmes
- Source Inputs, Build Steps, and Outputs
- Dependency Graphs and Incremental Builds
- Toolchain Pinning and Repeatable Builds
- Build-Time vs. Runtime Configuration
- Packaging Libraries, Applications, and Services
- Container Images as Deployable Artifacts
- Artifact Versioning and Provenance
- Software Bills of Materials
- Build Caches and Cache Correctness
- Producing and Promoting the Same Verified Artifact
49Continuous Integration and Delivery Pipelines10 thèmes
- Integrating Small Changes Frequently
- Pipeline Stages and Their Responsibilities
- Fast Feedback and Early Failure Detection
- Automated Tests and Quality Gates
- Branch Protection and Required Checks
- Pipeline Permissions and Secret Boundaries
- Artifact Storage and Promotion
- Parallel Work and Pipeline Dependencies
- Handling Failing and Flaky Pipelines
- Maintaining Delivery Automation as Production Code
50Environments, Deployment, and Release Management12 thèmes
- Development, Test, Staging, and Production Environments
- Environment Parity and Configuration Differences
- Deployment vs. Release
- Release Readiness and Change Approval
- Feature Flags and Controlled Exposure
- Rolling, Blue-Green, and Canary Deployments
- Database Migrations During Application Rollout
- Health Checks and Startup Validation
- Rollback vs. Roll-Forward Recovery
- Release Notes and Operational Communication
- Verifying User-Visible Behavior After Deployment
- Retiring Flags and Temporary Release Mechanisms
51Observability and Production Feedback11 thèmes
- Designing Software to Explain Its Behavior
- Structured Logs and Correlation Identifiers
- Metrics, Counters, Gauges, and Histograms
- Distributed Tracing and Request Paths
- User-Centered Indicators and Technical Indicators
- Instrumenting Critical Business Flows
- High-Cardinality Data and Telemetry Cost
- Dashboards That Support Specific Decisions
- Actionable Alerts and Alert Fatigue
- Protecting Sensitive Data in Telemetry
- Turning Production Evidence into Engineering Work
52Reliability, Recovery, and Incident Response11 thèmes
- Defining Reliability from the User's Perspective
- Service-Level Indicators and Objectives
- Error Budgets and Reliability Trade-Offs
- Timeouts, Retries, and Cascading Failure
- Circuit Breakers, Bulkheads, and Load Shedding
- Graceful Degradation and Reduced Functionality
- Backup, Restore, and Recovery Verification
- On-Call Readiness and Incident Roles
- Stabilization, Communication, and Recovery
- Blameless Post-Incident Analysis
- Turning Incident Findings into Verified Improvements
53Performance and Resource Efficiency11 thèmes
- Measuring Before Optimizing
- Latency, Throughput, and Resource Consumption
- Averages, Percentiles, and Tail Behavior
- CPU-Bound and I/O-Bound Work
- Algorithmic Improvements vs. Local Optimizations
- Caching and Cache Invalidation
- Batching, Pagination, and Streaming
- Reducing Database and Network Round Trips
- Memory Use, Allocation, and Resource Pooling
- Controlling Concurrency and Avoiding Overload
- Balancing Speed, Cost, Energy Use, and Complexity
54Legacy Systems and Maintenance11 thèmes
- Understanding a System Without Complete Documentation
- Corrective, Adaptive, Preventive, and Perfective Maintenance
- Recovering Intent from Code, Tests, and History
- Characterization Tests for Existing Behavior
- Identifying Hidden Dependencies
- Working Around Unsupported Components
- Incremental Replacement and the Strangler Approach
- Data Migration and Reconciliation
- Managing Old and New Implementations Together
- Avoiding Unnecessary Full Rewrites
- Planning Safe Retirement and Decommissioning
55Compatibility and Software Evolution10 thèmes
- Source, Binary, Behavioral, and Data Compatibility
- Public Contracts and Accidental Contracts
- Semantic Versioning and Its Limits
- Additive Changes and Breaking Changes
- Deprecation Policies and Migration Guidance
- API and Event-Schema Evolution
- Expand-and-Contract Database Changes
- Mixed-Version Systems During Rollout
- Preserving User Data and Existing Workflows
- Testing Upgrade, Downgrade, and Recovery Paths
Étape 6
Professional Practice
Le travail en équipe, au quotidien
6 modules · 61 thèmes
56Documentation and Knowledge Transfer9 thèmes
- Documentation for Users, Developers, and Operators
- README Files and Getting-Started Paths
- API References and Practical Examples
- Architecture Views and Decision Records
- Runbooks and Troubleshooting Guides
- Explaining Assumptions, Constraints, and Known Limits
- Documentation Close to the Code
- Keeping Documentation Current Through the Change Process
- Handoffs, Onboarding, and Reducing Single-Person Dependency
57Teamwork and Engineering Communication10 thèmes
- Shared Ownership and Clear Responsibilities
- Working with Product Managers and Designers
- Communicating with Nontechnical Stakeholders
- Writing Useful Issues and Technical Proposals
- Design Reviews Before Expensive Commitments
- Pairing, Mentoring, and Collaborative Problem Solving
- Asynchronous Collaboration and Decision Visibility
- Managing Dependencies Between Teams
- Escalating Risks and Blockers Early
- Disagreeing Constructively and Recording Decisions
58Engineering Management and Software Economics11 thèmes
- Estimating Effort Under Uncertainty
- Scope, Time, Cost, and Quality Trade-Offs
- Risk Identification and Contingency Planning
- Build vs. Buy vs. Reuse
- Total Cost of Ownership
- Opportunity Cost and Cost of Delay
- Capacity Planning Without Treating People as Interchangeable
- Managing Technical and Organizational Dependencies
- Forecasting with Ranges and Evidence
- Communicating Progress Through Outcomes and Risks
- Knowing When to Continue, Simplify, or Stop
59Process Improvement and Engineering Quality10 thèmes
- Processes as Tools Rather Than Goals
- Agile Principles and Feedback Cycles
- Scrum, Kanban, and Context-Appropriate Practices
- Work in Progress, Queues, and Flow
- Retrospectives and Small Improvement Experiments
- Defect Prevention vs. Defect Detection
- Delivery Speed, Change Failure, and Recovery Measures
- Avoiding Vanity Metrics and Perverse Incentives
- Quality Assurance Across the Life Cycle
- Improving Systems of Work Without Blaming Individuals
60Ethics and Professional Responsibility10 thèmes
- Public Interest and Responsibility for Software Impact
- Safety-Critical Contexts and Limits of Competence
- Honest Claims About Capabilities and Limitations
- Accessibility, Exclusion, and Unequal User Impact
- Privacy, Consent, and Responsible Data Use
- Intellectual Property and Open-Source License Awareness
- Conflicts of Interest and Professional Independence
- Reporting Risks and Unsafe Practices
- Sustainable Choices and Long-Term Stewardship
- Accountability for Decisions Made with Automated Tools
61AI-Assisted Software Engineering11 thèmes
- Appropriate Uses for Code-Generation and Assistance Tools
- Providing Relevant Context and Explicit Constraints
- Decomposing Work into Reviewable Tasks
- Checking Generated Code Against Actual Requirements
- Verifying APIs, Dependencies, and Technical Claims
- Reviewing Security, Privacy, and Licensing Exposure
- Using Independent Tests and Reference Behavior
- Bounded Tool Access and Human Approval
- Avoiding Automation of Unverified Assumptions
- Measuring Whether Assistance Improves Quality and Delivery
- Maintaining Human Ownership of the Final Result
Étape 7
Integrated Projects
Dix projets, du début à la fin
1 module · 10 thèmes
62Integrated Software Engineering Projects10 thèmes
- A Command-Line Application with Validation and Automated Tests
- A Reusable Library with Stable Contracts and Documentation
- A Data-Backed Application with Explicit Business Rules
- An API Service with Authentication and Authorization Tests
- A Background-Job System That Handles Retries and Duplicates
- An Accessible User Interface Connected to a Tested Service
- An External-Service Integration with Controlled Failure Handling
- A Legacy Refactoring with Characterization and Regression Tests
- A Production Release with Observability and a Recovery Exercise
- A Complete Software Product from Requirements to Maintenance Plan
Quinze minutes.Chaque jour.
- 1
Une leçon tient dans une pause déjeuner
Une idée à la fois, en diapositives courtes. Une leçon entière prend environ quinze minutes.
- 2
Des exercices corrigés à l'instant
Les questions sont dans la leçon. Répondez et voyez tout de suite si c'est juste.
- 3
Une série qui donne envie de revenir
Une leçon par jour entretient la série. De petites séances régulières vous mènent au bout.
- 1
Une leçon tient dans une pause déjeuner
Une idée à la fois, en diapositives courtes. Une leçon entière prend environ quinze minutes.
- 2
Des exercices corrigés à l'instant
Les questions sont dans la leçon. Répondez et voyez tout de suite si c'est juste.
- 3
Une série qui donne envie de revenir
Une leçon par jour entretient la série. De petites séances régulières vous mènent au bout.
Du premier commit à senior.
Autodidactes qui comblent leurs lacunes
Là où vous progresserez le plus
Écrivez des tests, de l'unitaire au bout en bout
Étape 4 · Security & TestingDiplômés de bootcamp en quête d'un premier poste
Là où vous progresserez le plus
Déployez via CI/CD et gérez les incidents
Étape 5 · Delivery & OperationsJuniors qui visent le poste de senior
Là où vous progresserez le plus
Menez un produit de la spec à la mise en production
Étape 7 · Integrated Projects
Où mène ce cours.
Le métier autour duquel ce cours est construit, et comment on y entre.
Software Engineer
Conçoit, écrit et maintient les logiciels sur lesquels tourne une entreprise.
Toutes les carrières d'avenirAu quotidien
- Découper une fonctionnalité en code que d'autres pourront maintenir
- Relire la modification d'un collègue et trouver le bug avant les utilisateurs
- Garder un système rapide et stable à mesure qu'il grandit
Comment y entrer
Un diplôme aide mais n'est pas exigé partout. Les employeurs regardent de près les vrais projets, le code sur GitHub et un entretien technique.
Soyez parmi les premiers.
Accès anticipé pour les particuliers, pilotes pour les équipes. Dites-nous qui va apprendre.
enterprise@astratrainer.com