If we were to even begin discussing the life of a full-stack developer, it would be worthy of a whole book by itself – so let's leave that for another day.
Let's look at a user story about a full-stack Java web application and see what is involved.
Let's use an example of developing a user management module for a typical Java web application. Let's assume that you would be writing unit test cases for the all the code hence we won't detail them out here:
- You would start by designing the architecture for the feature. You would decide on the plugins and frameworks to use, patterns to follow, and so on.
- You will be modeling the domain model for the feature depending on the database technology used.
- Then, you would create server-side code and database queries to persist and fetch data from the database.
- Once the data is ready you would implement server-side code for any business logic.
- Then, you would implement an API that can be used to provide data for the presentation over an HTTP connection.
- You would write integration tests for the API.
- Now, since the backend is ready, you would start writing frontend code in JavaScript or a similar technology.
- You would write client-side services to fetch data from the backend API.
- You would write client-side components to display the data on a web page.
- You would build the page and style it as per the design provided.
- You would write automated end to end tests for the web page.
- It is not done yet. Once you have tested everything works locally you would create pull requests or check-in the code to the version control system used.
- You would wait for the continuous integration process to verify everything, and fix anything that is broken.
- Once everything is green and the code is accepted, typically you would start the deployment of this feature to a staging or acceptance environment, either on-premises or to a cloud provider. If it is the latter you would be expected to be familiar with the cloud technologies used as well. You would also be upgrading the database schema as necessary and writing migration scripts when required.
- Once the feature is accepted you might be responsible for deploying it into the production environment in a similar way, and troubleshoot issues where necessary. In some teams, you might swap the steps with other team members so that you would be deploying a feature developed by your co-worker while s/he deploys yours.
- You might also be responsible, along with your co-workers, to make sure the production environment is up and running including the database, virtual machines, and so on.
As you can see it is no easy task. The range of responsibilities spawns across making stylesheet updates on the client side to running database migration scripts on a virtual machine in the production cloud service. If you are not familiar enough, this would be a herculean task and you would soon be lost in the vast ocean of frameworks, technologies, and design patterns out there.
Full stack development is not for the faint-hearted. It takes a lot of time and effort in keeping yourself up to date with various technologies and patterns in multiple disciplines of software development. Following are some of the common problems you might face as a full-stack Java developer:
- Client-side development is not just about writing plain HTML and JavaScript anymore. It is becoming as complex as server-side development with build tools, transpilers, frameworks, and patterns.
- There is a new framework almost every week in the JavaScript world and if you are coming from a Java background it could be very overwhelming for you.
- Container technologies such as Docker revolutionalized the software industry but they also introduced a lot of new stuff to learn and keep track of, such as orchestration tools, container management tools, and so on.
- Cloud services are growing day by day. To stay on track you would have to familiarize yourself with their API and related orchestration tools.
- Java server-side technologies have also undergone a major shift in recent times with the introduction of JVM languages such as Scala, Groovy, Kotlin, and so on, forcing you to keep yourself up to date with them. On the other side, server-side frameworks are becoming more feature rich and hence more complex.
The most important thing of all is the pain of making sure all of these work together well when required. It will need a lot of configuration, some glue code, and endless cups of coffee.
It's very easy to get lost here and this is where technologies such as JHipster and Spring Boot step in to help. We will see the details in later chapters but in short, they help by providing the wiring between moving parts so that you only need to concentrate on writing business code. JHipster also helps by providing the abstractions to deploy and manage the application to various cloud providers.