Fundamentals of Software Engineering in 3 weeks
Published by O'Reilly Media, Inc.
Skills for cultivating, preserving, and enhancing a large codebase
Undergraduate computer science curriculums may teach you the fundamentals of algorithms and writing code, but they rarely cover the multitude of topics that are vital to your success as a software engineer. There’s a vast array of knowledge you need to grow into the role...but where do you begin?
Join expert Nate Schutta to start your journey off right, through pointers and deeper dives into key topic areas such as how to get better at reading and writing code, how to collaborate as part of a team, design patterns fundamentals, refactoring, and testing and automation. By the time you’re through, you’ll understand the skills that really matter as a software engineer—and know how to apply them.
Week 1: Understanding Your Codebase
In Week 1 you’ll learn how to get into the software engineering mindset and how to approach reading and writing code.
Week 2: Design Fundamentals, Pattern Recognition, and Refactoring
Week 2 focuses on design patterns, including the Gang of Four, along with how to work with legacy code, refactoring, and testing and automation. You'll also learn best practices that will help you upskill as a developer.
Week 3: IDE, Command Line Tips, and Tricks
In Week 3 you’ll discover how to choose an IDE, dive into troubleshooting architecture issues, and learn how to build a postmortem culture in your organization.
What you’ll learn and how you can apply it
By the end of this live online course, you’ll understand:
Week 1: Understanding Your Codebase
- Key elements to keep in mind when shifting into a software engineering role
- Best practices for reading and writing code as part of a team
- How to communicate and collaborate effectively with stakeholders
Week 2: Design Fundamentals, Pattern Recognition, and Refactoring
- Fundamentals of design and architectural patterns
- Best practices for working with legacy code, refactoring, testing, and automation
- Strategies for career growth and knowledge sharing
Week 3: IDE, Command Line Tips, and Tricks
- Which IDE is best for you
- How to identify issues with your architecture
- How to approach postmortems
And you’ll be able to:
Week 1: Understanding Your Codebase
- Improve your code reading and writing skills
- Implement new ways of approaching and working through problems
- Collaborate effectively with your team and key stakeholders
Week 2: Design Fundamentals, Pattern Recognition, and Refactoring
- Use design patterns and leverage TDD
- Refactor more efficiently
- Build on your software engineering skills and grow your career by sharing your knowledge
Week 3: IDE, Command Line Tips, and Tricks
- Solve architecture blockers and become a better developer
- Build a stronger postmortem workflow
- Determine what work-life balance means for you and set some ground rules for yourself
This live event is for you because...
- You’re a newly minted software engineer.
- You’re looking to upskill as a software engineer.
- You want a refresher on engineering concepts.
Prerequisites
- A basic understanding of programming
Recommended follow-up:
- Read Software Engineering at Google (book)
- Read The Manager’s Path (book) or listen to the audiobook
- Read Being Geek (book)
- Take Agile for Everybody (live online training course with Matt LeMay)
Schedule
The time frames are only estimates and may vary according to how the class is progressing.
Week 1: Understanding Your Codebase
Programmer to engineer (35 minutes)
- Presentation: What does it mean to be a software engineer?; embracing the lazy programmer ethos; why best is highly subjective
- Q&A
Reading code (55 minutes)
- Presentation: Approaching a new codebase; why reading code is harder than writing code
- Hands-on exercise: Determine what a given code block is doing
- Q&A
- Break
Writing code (55 minutes)
- Presentation: Code is a communication mechanism; All code is legacy code unless we throw it away; code linters and other tools
- Hands-on exercise: Determine what’s wrong with a given code block
- Q&A
- Break
All of us is smarter than one of us (35 minutes)
- Presentation: Code is a collaborative game (working with product owners, QA, DevOps, UI, etc.); communicating with nontechnical stakeholders; the cone of uncertainty; fast, cheap, and good—pick two
- Q&A
Week 2: Design Fundamentals, Pattern Recognition, and Refactoring
Design patterns for fun and profit (40 minutes)
- Presentation: A gentle introduction to the Gang of Four; architectural patterns
- Group discussion: Which patterns do you see most often?
- Q&A
Refactoring (50 minutes)
- Presentation: Working with legacy code; refactoring 101; leaving the code better than you found it
- Group discussion: Which refactoring do you use most often?; What’s the worst comment you can see in code?
- Q&A
- Break
Testing and automation (50 minutes)
- Presentation: The testing continuum; TDD for fun and profit; Small batches aren’t just for bourbon; small steps for the win; CI/CD
- Group discussion: What kinds of tests do you typically write?; When do you typically write tests?
- Q&A
- Break
Learning to learn (40 minutes)
- Presentation: Establishing habits; sharing what you know; distributed knowledge; avoiding résumé-driven design
- Group discussion: What are you focusing on right now?
- Q&A
Week 3: IDE, Command Line Tips, and Tricks
Putting it into practice (60 minutes)
- Presentation: Learning your IDE or editor of choice; tips and tricks (Number 7 will blow your mind!); why you should spend 10 minutes a week learning about your tool of choice
- Group discussion: What’s your preferred IDE?
- Q&A
- Break
My architecture is a mess; now what? (60 minutes)
- Presentation: What is architecture?; accidental architecture; evolving to your desired end state; fitness functions
- Hands-on exercise: Identify a fitness function
- Q&A
- Break
Learn from the past (30 minutes)
- Presentation: Your knowledge base (You will run into this again; write it down...somewhere.); the importance of postmortems; building a postmortem culture
- Group discussion: How frequently do you perform retrospectives or postmortems?
- Q&A
Work-life balance (30 minutes)
- Presentation: How to enjoy the journey; why you should unplug
- Q&A
Your Instructor
Nathaniel Schutta
Nathaniel T. Schutta is a software architect and Java Champion focused on cloud computing, developer happiness and building usable applications. A proponent of polyglot programming, Nate has written multiple books, appeared in countless videos and podcasts. He’s also a seasoned speaker who regularly presents at worldwide conferences, meetups, universities, and user groups. In addition to his day job, Nate is an adjunct professor at the University of Minnesota, where he teaches students to embrace (and evaluate) technical change. Driven to rid the world of bad presentations, he coauthored the book Presentation Patterns with Neal Ford and Matthew McCullough, and he also published Thinking Architecturally and Responsible Microservices available from O’Reilly. His latest book, Fundamentals of Software Engineering, is now available.