OpenCourser
Learn skills that shape your future
Visit OpenCourser.com
The TDD Masterclass by Petros Efthymiou.
Learn State-of-the-art Android development by building a real production app.
Are you following dozens of forums and articles and buying courses in order to move your development skills and career to the next level?
The TDD Masterclass by Petros Efthymiou.
Learn State-of-the-art Android development by building a real production app.
Are you following dozens of forums and articles and buying courses in order to move your development skills and career to the next level?
I am, too, but more often than not, after completing them, I realize that there is still a HUGE amount of work left to be done to connect all the pieces together and make them work on a real application. I found that even though a course was providing comprehensive knowledge on coroutines, it didn't mean that I knew how to integrate them with Retrofit, Live data, or Hilt. And because another course was extensive on Test Driven Development after completing it, I didn't know how to write an application with TDD using the latest Android tech stack.
After buying courses, reading articles & forums, and a couple of months of hands-on practice, I have finally learned how to combine Android 11 best development practices in an Android application.
I created this course to make the process easier for you. You are going to learn how to combine
Kotlin
Coroutines
Live Data
Kotlin Flow
Retrofit
Hilt
Jetpack Navigation
MVVM
And complete a real Android application purely on Outside-In Test Driven Development
You are going to learn how to write not flaky espresso tests in a real scenario with delays and HTTP calls, without using Thread.sleep(). After all we wouldn't be doing TDD without efficient & effective Espresso UI tests.
Why Me?
Even though I am new to Udemy, I am not new to the industry. I have been working as an Android engineer from junior to lead positions in ambitious startups & large multinational companies for about 8 years. Being a good engineer, though, doesn't automatically mean that you are a good Instructor as well.
In the past 5 years I have also discovered my passion for education and worked as a Software Instructor in several colleges and companies, including New York College, Hellenic American Union my current position is a Mobile Trainer in a Multinational company called Backbase, where I am training
The internal RnD engineers
The internal professional services engineers
External third-party integrators
In my lifetime, I have trained thousands of developers in classrooms, web conferences, and video courses.
Why is it important?
As we advance to more senior engineering levels, we realize that how we do things is equally important to get them done. The industry has started to realize that a serious software engineering company can no longer base its products on purely architectural and engineering practices.
I often say that there are 3 stages in the advancement of an engineer
In the first stage, he/she is a programmer. He is learning how to make things work, e.g., how to add buttons in an Android application and handle its click. But is not aware of the importance of doing things well. He or she cannot realize that a purely structured system is certain to backfire in the long run, and while everything initially seemed to be going well, "suddenly," it is impossible to work with this system anymore. New features are hard to add, and bugs very often slip to production code
In the second stage, having realized the past mistakes, the professional starts practicing and learning good engineering patterns. He or she starts exploring things like :
SOLID Principles
Design patterns
Clean architecture
Separation of concerns
Low coupling, High cohesion
Unit Testing
and if is passionate and dedicated enough, manages to reach a more senior level, and is able to develop systems that can be successful not only in the short but also in the long run
The final stage is the Mastery. This stage is an ongoing process and doesn't ever end. After the engineer has a good understanding of the above practices, he realizes there is a huge room for improvement. He learns how to apply them and, most importantly, when they are not required, and simpler-junior level approaches are more beneficial for the specific project/situation. In other words, it is a constant effort to learn how to never
Under-Engineer
Or Over-Engineer.
He or she also comes in touch with more advanced practises like Test Driven Development which takes quite a lot of effort to get a grasp and master it.
In this course, I will do my best to advance you on this path. I will offer you what I have learned on my journey, and I am also very open to learning from you. I am always available on the forums to support and discuss topics that you might have a different point of view, and this way, we can help each other on our endless road to Software Mastery.
Let's discuss what TDD is.
Let's touch base on what is a Test
The solution to the exercise
What characteristics make a Test valuable?
Let's discuss of all the different types of automated Tests
Discussing Google's suggested testing strategy
How many TDD types exist?
Pros & Cons of TDD types
Which is our favourite TDD flavour?
One additional step
The requirements of the first system that we are going to develop using outside-in TDD
In this video we are going to write our first failing acceptance test that validates the system behaviour
In this video we will complete the first inner TDD cycle
Let's write the second acceptance test for the second part of our desired system behaviour
In this video we are going through the whole Inner TDD cycle for the Car class.
In this video we are going through the while Inner TDD cycle for the Engine class
Finally we complete the whole implementation of our system and our Acceptance Test is passing !
What you learned regarding TDD?
Let's discuss what problems do coroutines solve & why do we need them
Explaining 2 new operations, the Suspend & Resume
Let's see what happens in the background while we write straightforward sequential code
How do coroutines achieve Main Safety?
Let's discuss an important concept called structured concurrency
Let's see coroutines in practise !
Learning how to write unit tests for Coroutines
Reactive Programming with Kotlin Flow
Let's discuss the advantages of Kotlin Flow VS Rx
Let's get some hands on experience using Kotlin Flow
Let's see how can we unit Test a Kotlin Flow
In this video we are closing up the implementation of our example system
Let's discuss the basic principles that will enable us to deliver fast, high quality code
Let's discuss the requirements of our MVP Android application
We are going to use Mockoon in order to make a real Backend environment on our localhost
Please download the start application attached to this video
Our first acceptance test is passing !
Implementing the failing Acceptance test for our playlists list
Let's discuss an interesting concept that I like to call Minimum Viable architecture
Creating the user interface for our playlists feature
Implementing the Fragment
Finishing the development cycle for the view layer.
Writing the first red unit test for our ViewModel layer
We are turning the second unit test of our VM Green!
Never forget to refactor both the production & the test code
It is very important to also test how our system is applying error handling
Starting the inner TDD cycle for the Playlist Repository
In this video we reach the Green state for the emitPlaylistsFromService Test!
Finishing with the repository layer, do not forget that we must also implement the error handling!
We are turning green the first desired behaviour of our Service Test
Let's complete the implementation of our service layer by testing the error handling
Let's first make sure that we understand what dependency injection is
Let's discuss the advantages of using dependency injection in your project
Let's discuss Google's HILT DI library and why it is the best choice currently for an android application
Evaluating our situation and what dependency injection means to our project
Let's include the HILT library to our application
Let's learn the steps to perform dependency injection using the HILT library
In this video we are going to finish the HILT library integration
Let's test the behaviour of our application after integrating HILT
After demo-ing the application to our team we are receiving some improvements from our Product Owner
Starting off with the failing acceptance test for our improvement as always
Implementing the first part of our improvement
Correcting broken past behaviour and implementing the second failing acceptance Test.
Completed the whole implementation of the loader functionality
Writing the first failing acceptance first for our second improvement
Let's discuss what is the best way to add business logic inside our application
We need to refactor our system to make to map the PlaylistsRaw to Playlists before we proceed with our second improvement
We need to make sure that the repository is delegating the playlist mapping
Finished the repository implementation
Now let's focus on implementing the business logic with the mapper
Going through the rest of the TDD cycle for our mapper
Getting the green light for the second improvement
Let's discuss what the Jetpack Navigation is
SaveSaveSaveOpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
