- Source Code & Resources PRO
- Lesson 1: Introduction PUBLIC
- Lesson 2: The Structure of this Module PUBLIC
- Lesson 3: [Sprint One] Setting up Firebase PUBLIC
- Lesson 4: [Sprint One] Creating Security Rules with TDD PRO
- Lesson 5: [Sprint One] Testing Authentication PRO
- Lesson 6: [Sprint One] Component Store PRO
- Lesson 7: [Sprint One] Circumventing Firebase Authentication for E2E Tests PRO
- Lesson 8: [Sprint Two] Displaying Client List from Firestore PRO
- Lesson 9: [Sprint Two] - Adding Clients PRO
- Lesson 10: [Sprint Two] - Editing Clients PRO
- Lesson 11: [Sprint Two] - Client Details PRO
- Lesson 12: Preparing for Delivery PRO
- Lesson 13: Configuring for Production PRO
- Lesson 14: [Sprint Three] - Refactoring PRO
- Lesson 15: [Sprint Three] Setting up PWA PRO
- Lesson 16: [Sprint Three] Logout PRO
- Lesson 17: [Sprint Three] Delete a Client PRO
- Lesson 18: [Sprint Three] - Feedback Mechanism PRO
- Lesson 19: [Sprint Three] View Feedback PRO
- Lesson 20: More Styling PRO
- Lesson 21: [Sprint Four] - Refactoring Feedback PRO
- Lesson 22: [Sprint Four] - Feedback Dates PRO
- Lesson 23: [Sprint Four] - Client Survey PRO
- Lesson 24: [Sprint Four] - View Survey PRO
- Lesson 25: Final Touches PRO
- Lesson 26: Conclusion PRO
Hello, and welcome to either the Creating a Modern Firebase Powered Application with TDD or the Project Management for Professional Ionic Applications module of Elite Ionic!
These two modules are quite different to a lot of the other modules on Elite Ionic for a couple of reasons. First of all, and most obviously, because they are connected. Whether you have started the project management or Firebase TDD module, you will be watching this video.
The key idea for these modules is that it documents the creation, in a step-by-step manner, of a real life project I created for a real client. It is a Firebase powered application that was built using Test Driven Development, and not only have I documented the entire build step-by-step, I have also detailed and documented the entire project management strategy and process I have been using - everything from requirements elicitation and planning, to documentation, to Git repos, to CI/CD, and more.
Originally, this was going to be one individual module that encompassed both the application build and the project management side of things, but I split it into two modules for a couple of reasons. One was simply because of the sheer size of it, even as separate modules they are still quite massive. But perhaps more importantly because we are really addressing two separate things. One module focuses on project management, and the other on the application build itself. Both of these work well together, and complement each other if you want to complete both at the same time, but - you might only be interested in the project management side of things, or maybe you are only interested in the application build. By splitting these modules into two, you can pick and choose what you want to do.
Keep in mind that if you do want to complete both modules, you should start with the project management module. There are quite a few lessons to complete in that module before the application build begins in the other module.
The project management module is all about learning how to manage building a real world Ionic app in a professional way, specifically focusing on the ideas and tools outside of the actual coding of an application. This includes things like setting up project management tools in your repo, soliciting and interpreting design requirements from a client, managing the work that arises from that, agile development philosophies, setting up continuous integration and deployment, tests, delivering iterations to the client and more.
The application build module on the other hand is all about building a modern Angular and Firebase application using the TDD methodology to drive the development. We look at how to write unit tests for Firestore security rules, setting up emulators for local development, developing the application with a test driven development methodology, architecting the application in a scalable manner, and programming everything with a reactive approach.
I wrote this module as I was working on a real application for a real client that they are going to really use in the real world. A lot of the time we just focus on hypothetical examples, and often for good reason, but in this case I think it makes sense to have a real life example to follow along with. Real projects naturally take twists and turns and have weird requirements that you hadn't considered, and it's important that our software development process is able to deal with these twists and turns outside of the context of tutorials that are generally designed to work out nicely.
If you do intend to do both modules at some point, there will be a rather strong benefit to actually doing them together at the same time. I feel like a lot of the points will be reinforced more if you are actually coding along and going through all of the steps yourself.
In general, this is how I would recommend approaching completing these modules together:
Treat it like a typical code-along style tutorial - I do walk through everything step by step in this manner. Actually do all the project management stuff, create the issues, create the pull requests, write the tests, run the tests and so on. I walk through solving all of the test errors that I run into along the way and that always provides an interesting learning opportunity. But chances are you will run into errors and issues that don't exactly line up with what I am describing. My advice is to treat this as a learning opportunity as well, see if you can figure out how to solve the issue. If you can't figure out an issue that relates to a test failure, you can always just comment out that test and address it later.
I've tried to make this module as "real world" as possible, and that does mean that sometimes we are dealing with long, complicated, and frustrating issues along the way. This module will likely be more painful to get through than a lot of the other ones, but try to embrace the pain - there is a lot to be learned here that you won't find in "typical" tutorials.