<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Engineering Foundations on DATATWEETS</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/</link><description>Recent content in Engineering Foundations on DATATWEETS</description><generator>Hugo</generator><language>en</language><copyright>Copyright (c) 2025 Datatweets</copyright><lastBuildDate>Sun, 05 Jul 2026 09:00:00 +0200</lastBuildDate><atom:link href="https://datatweets.com/courses/software-engineering/engineering-foundations/index.xml" rel="self" type="application/rss+xml"/><item><title>Lesson 1 - Core Principles of Software Engineering</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-1-core-principles-of-software-engineering/</link><pubDate>Sun, 05 Jul 2026 09:00:00 +0200</pubDate><guid>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-1-core-principles-of-software-engineering/</guid><description>This lesson breaks down the six ideas that separate maintainable code from a tangled mess: modularity, abstraction, encapsulation, reusability (DRY), simplicity (KISS), and restraint (YAGNI). Every example comes from Ledgerly, a small invoicing and subscription-billing app, showing a &amp;lsquo;before&amp;rsquo; version that violates the principle and an &amp;lsquo;after&amp;rsquo; version that fixes it. By the end, you can recognize each principle in real code and explain why it matters.</description></item><item><title>Lesson 2 - The SOLID Principles</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-2-the-solid-principles/</link><pubDate>Sun, 05 Jul 2026 09:00:00 +0200</pubDate><guid>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-2-the-solid-principles/</guid><description>SOLID is five rules for object-oriented design: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Using Ledgerly&amp;rsquo;s Invoice, PaymentGateway, and Subscription classes, this lesson shows a real violation of each principle next to its fix, with output from actually running the code. You will finish able to spot a SOLID violation in a code review and explain how to correct it.</description></item><item><title>Lesson 3 - The Software Development Lifecycle</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-3-the-software-development-lifecycle/</link><pubDate>Sun, 05 Jul 2026 09:00:00 +0200</pubDate><guid>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-3-the-software-development-lifecycle/</guid><description>This lesson walks the Ledgerly team through the six phases of the software development lifecycle: requirements analysis, design, implementation, testing, deployment, and maintenance. Each phase is grounded in one real feature — automatically emailing customers about overdue invoices — with runnable Python showing what implementation and testing actually produce. You will also see why the SDLC is a repeating cycle rather than a one-time checklist.</description></item><item><title>Lesson 4 - Development Methodologies</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-4-development-methodologies/</link><pubDate>Sun, 05 Jul 2026 09:00:00 +0200</pubDate><guid>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-4-development-methodologies/</guid><description>A development methodology is the set of rules a team uses to plan, build, and release software. This lesson follows the three-person Ledgerly team as they pick two-week Scrum sprints for building invoicing features, run a Kanban board with work-in-progress limits for support tickets, and consider a stricter Waterfall-style process for a compliance feature. You compare Scrum&amp;rsquo;s roles and ceremonies, Kanban&amp;rsquo;s pull-based flow, and a decision guide for choosing, or blending, methodologies based on team size, requirement stability, and regulatory pressure.</description></item><item><title>Lesson 5 - Guided Project: Planning Ledgerly</title><link>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-5-guided-project-planning-ledgerly/</link><pubDate>Sun, 05 Jul 2026 09:00:00 +0200</pubDate><guid>https://datatweets.com/courses/software-engineering/engineering-foundations/lesson-5-guided-project-planning-ledgerly/</guid><description>In this guided project you join the Ledgerly team as a new engineer and take one real feature from idea to code: a 7-day overdue escalation notice. You write user stories and acceptance criteria, choose and justify Scrum for the work, map the feature onto all six SDLC phases, and build a SOLID-respecting OverdueInvoiceNotifier that depends on NotificationService and InvoiceRepository abstractions instead of concrete classes. A real Python test then proves that dependency inversion is what makes the feature easy to verify without sending a real email.</description></item></channel></rss>