- Source Code & Resources PRO
- Lesson 1: Introduction PUBLIC
- Lesson 2: The Agile Methodology PUBLIC
- Lesson 3: Project Planning PUBLIC
- Lesson 4: Initial Client Meeting PRO
- Lesson 5: Planning and Prototyping PRO
- Lesson 6: Diagrams and Documentation PRO
- Lesson 7: User Stories PRO
- Lesson 8: Project Management Overview PRO
- Lesson 9: Setting up the Project PRO
- Lesson 10: Continuous Integration PRO
- Lesson 11: Cypress Dashboard PRO
- Lesson 12: Continuous Deployment PRO
- Lesson 13: A Change Request PRO
- Lesson 14: Planning the First Sprint PRO
- Lesson 15: Merging with Pull Requests PRO
- Lesson 16: Configuring CI for Firebase PRO
- Lesson 17: Sprint One Review PRO
- Lesson 18: Sprint Two Review PRO
- Lesson 19: Sprint Three Review PRO
- Lesson 20: 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.