Become a Senior Developer
Imagine being able to solve more complex software problems than ever before and write beautiful code that’s easy to maintain or extend. Imagine taking a quantum leap in your software developer career and completely change the way you approach software design.
Did you know the difference in salary between a junior and a senior developer in the US is $40,000 on average per year?
This shows how important it is to invest in yourself: the potential gain is enormous! Becoming a senior developer means you have to be a great programmer. To become a great programmer, you have to know how to solve the complex problems that no one else can solve. Learn to structure problems logically so you can translate them into software. You have to adopt the mindset of a software designer.
But how do you get there? There’s a lot of great material online that will help you, but there’s also a lot of wrong, outdated information and bad coding practices that are still being promoted today.
You can try to walk this path alone, spend a lot of time trying to figure out what you need to learn, and then having to unlearn things again if you follow the wrong advice. You might end up farther away from your goal of becoming a senior developer, throwing away thousands of dollars per month because you’re not able to make that next move in your career.
But why make it so hard on yourself if there’s another path?
A path where you’re intentional about investing in yourself.
A path where you’re not alone, where you’re surrounded by peers.
A path where I’ll be there alongside you to guide you, to teach you the best practices of software design that get you results, and to make sure you unlock your full potential.
Introducing: The Software Designer Mindset
This course provides a modern take on software design, and teaches you a designer mindset that will allow you to consistently make better design decisions, getting you ready to take the next step in your career where you’ll be able to design complex software, immensely improve your existing code, and create software that is easy to change and scale.
The course uses Python for all code examples. Having some knowledge of programming in Python is therefore recommended before following this course. However, what you'll learn in the course you'll be able to apply to any programming language and software project.
Solve complex software design problems with ease
Refactor existing code to be future-proof and scalable
Take a major leap in your career as a software engineer
Easy-to-follow examples in Python
I've been passionate about programming and computer science since I was a kid. I've completed a Master and PhD in Computer Science and I have more than 20 years of teaching experience. I've launched several startups and designed and built complex software products from scratch. My goal with this course is to help you become a senior software engineer, by teaching you everything I know about software design.
What my students say about the course
"It is refreshing to see this complicated matter being explained in a way that is easy to understand, in easily digestible parts that are not too long, thereby providing insights I didn't have before. Such as to not focus on design patterns per se, but on the underlying principles: e.g. strategy can be implemented also without using protocols/abc (or interfaces in Java)"
"The course lets you understand the underlying principles of software design in a very accesible way. Good examples and also you discuss trade-offs. And it teaches very well that there are no hard and fast rules that apply always. There are the principles that guide you in when to apply what ('the mindset'). You still have to think for yourself :-)"
"I liked how your course (and your Youtube Channel) is mostly focused on software development and only uses the language to teach the concepts. I think that is, if not unique, something that is missing from a lot of other people doing programming content."
"It's much more fun to work on my own code now after applying some of the principles I've learned from your course to it!"
"I've enjoyed the way that you treat the concepts, making it very easy to understand with your explanation. I've also appreciated the content to the course, focus on more theory and principles, aming to teach why things are the way they are and why some ways are better than others."
"The challenging quizzes and the deep dive into before and after codes. Also, showing different methods to achieve a similar goal. My main objective is to apply high cohesion and reduce coupling in our current code as best as I can. Our current code = Spaghetti."
This course is for you if:
- You have some programming experience and you want to take your skills to the next level.
- You truly want to become a better software developer and you’re willing to invest in yourself and put in the work.
- You want to grow into a senior software developer position, but you want to do it efficiently.
- You love writing beautiful code that feels like it’s the perfect fit to a software problem.
- You want to learn how to setup larger software projects without breaking a sweat.
This course is NOT for you if:
- You have no programming experience at all.
- You expect results without putting in the effort. You have to be serious about becoming a senior software developer and be willing to put in the time and follow the principles.
- You expect a course that covers in-depth software testing techniques. This course focuses on software design. However, applying the principles will lead to software that’s a lot easier to test.
- You expect a course that covers design patterns. This course focuses on something deeper: the principles behind the patterns, and the mindset you need to come up with your own patterns.
- You hate Python :).
Here’s an overview of what you’ll learn inside The Software Designer Mindset:
Module 1: Mastering The Tools
Setting Up Your Development Environment - Learn how to setup your development environment for success (this is more important than you think): which plugins/extensions to use and what settings to change to make your life easier.
Types And Type Hints - Knowing what types and type hints are and how they work in Python is really important. In this lesson I dive into the details of type systems, how things work in Python, and show you best practices so you get the most out of using type hints.
Data Structures - A core piece of software design is using data structures correctly. Each data structure has its own pros and cons. Knowing about these is going to help you take better decisions about which data structure to use when.
Classes And Data Classes - Though this is not a complete introduction of object-oriented programming, I talk about classes and data classes in detail in this lesson and how they fit into software design.
- The Mighty Function - This lesson is a deep dive into functions: what they are, more advanced things you can do with them and when to use functions as opposed to classes in your design.
Inheritance, ABCs And Protocols - In the final lesson of this module, you learn about abstraction, which is a core element of software design. I cover the various ways in which you can achieve abstraction in Python to help you choose the best option for your design.
Module 2: The 7 Principles Of Modern Software Design
The second part of the course presents the 7 Principles Of Modern Software Design. It takes many of the existing design principles and adapts them to the needs of the modern software designer. It goes way beyond object-oriented design by teaching you generic principles that apply to any programming language and paradigm, whether that’s object-oriented, purely procedural, or functional.
- Favor Composition Over Inheritance - Learn how to approach inheritance in code and use it in a balanced way by looking at several code examples.
- High Cohesion - Various techniques for making sure that the code you write has clear responsibilities.
- Low Coupling - Learn how to reduce coupling between different areas of your application so that your code is easier to maintain in the future.
- Start With The Data - What role does data play in the design process? When should we think about data and data structures in software design? And what is a practical process for modeling the data structures in your software?
- Depend On Abstractions - Abstractions such as ABCs and Protocols help reduce dependencies. In this lesson I show you how to use these abstractions effectively.
- Separate Creation From Use - You learn different ways of creating objects in a software system, and how to have better control as a software developer over how and when objects are being created.
- Keep Things Simple - As a software developer, how do you keep things simple? I talk about different ways to make sure your code stays simple, even if the application itself is complex.
Module 3: Being A Responsible Developer
- Mixins - You learn what Mixins are, why you need to be very careful with them, and what the much better alternatives are.
- Dealing With Errors - Any application has to properly deal with errors. Here you learn how error handling works in Python, what the different possibilities are as well as some of the more advanced error handling mechanisms such as context managers.
- Setting Up A Complex Software Project - Learn about files, folders, modules, packages, absolute and relative imports. Learn how to structure your code properly, and what should generally be in a code repository.
Module 4: Developing An API [COMPLETE/PROFESSIONAL Edition Only]
This module truly takes the course to the next level, offering an in-depth, practical case study where I teach you how to build an API from scratch in Python. I'll go through the entire process with you covering every aspect:
- Modelling The Domain - Why understanding the domain before you start developing is important, and how you can quickly create a model using dataclasses.
- Project Scaffolding - Complete scaffolding of an API product, learn to quickly setup an API server, integrate with a database and design the data structures that you'll need.
- Architecture - Setup the architecture of the API, and structure your code accordingly, applying the principles you've learned in the first three modules to make the code future-proof.
- Building Out The System - Create multiple endpoints, implement the basic operations of the API, using a clean architecture to nicely separate the different areas of the API.
- Creating A Testable API - Add unit tests to the API software to make the code more robust. Learn how architecture and design help make testing your code a lot easier.
- Using AI Sparring (NEWLY ADDED!) - Learn how to effectively use AI tools such as ChatGPT by asking 4 types of questions that help you design great software.
Module 5: Design Wins [COMPLETE/PROFESSIONAL Edition Only]
A really fun series of 15 videos, each highlighting one simple thing you can do to improve your software's design that takes only a few minutes from avoiding type abuse and writing symmetrical code, to avoiding redundancy and using protocol segregation.
Each part of the course has code examples written in Python that you can download, there are quizzes and exercises for you to sharpen your design skills, and each lesson is filled to the brim with tips and tricks taken from my own experience of teaching computer science and developing complete software products.
Enrollment also includes access to a private student community. Connect with people from all around the world who are on the same learning path as you, exchange ideas, find new friends to start exciting software projects with, and get extra support when you need it!
The Software Designer Mindset: Team Packages
Team packages of this course are now available to businesses and institutes. Whether you have a team of software developers, data scientists, or researchers, the packages are aimed at helping your team build much higher quality software while working more efficiently. It's a one-time investment that pays off forever. Contact me if you'd like to know about the possibilities for your team.Contact me
Don’t forget: it’s completely risk free
I’ve packed a lot into The Software Designer Mindset, because not only do I want you to succeed as a senior software developer, but I want to guarantee that you don’t fail.
And to make it a no-brainer deal for you I’m giving you a 30-day 100% money-back guarantee with your purchase of The Software Designer Mindset today.
That’s right: go through the course material, follow the steps, put in the work, and if you don’t love it in the first 30 days of your purchase, send me an email and I’ll refund you immediately. No questions asked, no hard feelings.
If The Software Designer Mindset doesn’t work for you, I’d much prefer for you to take your money and invest it where you will be happier and get results. I just want you to unlock your full potential!
Frequently Asked Questions
Do I need to know how to code before I start?
How is the course different from the free content on YouTube?
Is the course regularly updated and do I get access to the updates?
How does the code review in the PROFESSIONAL version work?
Do the videos have English subtitles?
I don't have a credit card. Is there another way for me to pay?
What if I still have questions?
The beauty of The Software Designer Mindset is that you can learn all the software design best practices, taken from my more than 20 years of experience teaching computer science and developing products, skip all of the pain and mistakes that I made, all in one package, available 24/7, that you can go through at your own pace.
It couldn’t be easier or more convenient!
Do your future self a favor and be brave. Invest in yourself, get the training that you need, and unlock your full potential as a software designer. Your life will never be the same!
See you on the inside...