Recently, fullstack development with Java has become very popular. This concept is usually backend oriented and involves basic level frontend improvement. As I wrote in my full stack development post, i think it is impossible for a person to have both a frontend and backend mentality at the same time and specialize in both. This is why, people are usually either backend focused or frontend focused fullstack developers. In this post, i have written about the subjects and some details that must be learned while starting from scratch to be a backend focused fullstack developer with Java.
So that, you can take this post as a guide and complete the subjects one by one and gain the necessary skills. Of course, it might take months or years to understand these subjects with details. If you would think that this journey will be short and software is just about writing code, you wouldn't have been reading this post :) I will not offer resources where you can learn the these subjects, because every person have different styles of learning that suits them. It is impossible to have a course that best explains Java or Restful services in the world.
If you somehow find a bootcamp or developer training, you will notice that the topics are accumulating and the former topics are the prerequisites of the later ones. At later stages, there are questions you need to know the answers of. There are some example questions for you in this post. In the end, it can give you an idea to test your own level. I will focus on the basics as much as possible, because technologies and languages can change over time. Of course, this article will focus mainly on being a Java developer. If you work in .Net or other languages, or want to be a frontend focused fullstack developer, your path will and should be different.
In the beginning, there was nothing. And bam! There was the big Java bang. Regardless of your level, you need to know what is the Java ecosystem. When you are working with Java, there are libraries and tools and frameworks getting involved. We are actually completing small pieces within a big picture like a puzzle. For example, what skills will we have at the end of process? I even start from the history of programming and talk about what is programming, at length. Because there is a history of like 50 years behind. We haven't come here in a day.
Then you need to familiarize with the features like JDK - JRE - JVM, that make Java, Java. Because Java is both a language and a programming structure. There needs to be an explanation as to why we are learning Java. At this point, there are many questions to be asked, like what is bytecode, what is platform independence, what is Java's relation with C and C++, what is native code ...etc.
Software development is basically telling computer what to do and how to do by implementing an algorithm. Therefore, when writing Java, we need to know how to command to do a repetitive process or execute conditional tasks. To implement these concepts in Java, our first step is to write a main method and a class. The may sound funny to you, but you should be able to write a main method with your eyes closed. The classes we write hold certain data and produces results that we want. We need to understand methods, variables, loops and conditional expressions. This is actually like Lego pieces.
Of course, the concept of class is vital in Java. There are many questions here, what is referencing, what is new, what is a constructor, what is this keyword ...etc. These are not the parts that should just be memorized. You should be able think in a Java mindset. Just as we become native when we speak a foreign language without thinking, the same applies for programming languages. It needs to be imposed in your mindset.
Although it is not mandatory, it is useful to have knowledge about Java's memory management in the background. Which areas of the memory are managed and how? And what they mean? It is important to understand what is garbage collection, what is deleting data that is not used and what we mean by unused data. Because Java's call-by-reference logic will also be mentioned somewhere in this topic.
So far, we have learned how to give orders to java. We write 1 line of code and the there is carnage in the background. At this stage you realize whether you want to progress in java software development mentality. You need to see where this language will take you. Now that you know the language, you can start creating designs with its possibilities.
These topics are, of course, our object oriented programming concepts. Here, we need to be able to explain why we do OOP and what would happen when we do not do it. Why don't we write straight structured code like C and constantly talk about concepts like classes, abstract structures, interfaces and overrides? Why might it be necessary for classes to have relationships with each other? Of course, these issues are way too abstract and they cannot be understood only through technical explanations. In fact, if you ask me, when you explain these issues with fancy words, it is useless.
These abstract concepts need to be written down and we need to witness the results. First, we need to see what are the results without using these concepts and what it causes. Otherwise, the abstract classes or interfaces or different dependency injections we will see in the future will not make sense to us. When looked from the outside, some libraries or frameworks or even the explanations written in the documentation, it will seem like they were written arbitrarily to you. Java consensus starts here.
Exception handling is not the most vital subject in Java itself, but it is useful to know. It may not be a topic to write in detail, but as your projects grow, your problems also grow and diversify. When it comes to exception handling, you can ask what to do for logical errors or system errors, alongside coding errors.
People who attended my trainings would know how much i emphasize these 3 issues :) Especially annotations and refection is important to know, even if they can't be fully absorbed at the beginning. Because it shows up a lot later in libraries or frameworks. For example, collection classes could exist without the generics, but they could only hold objects and it would be difficult to ensure type safety. Without annotations, we couldn't expose information about methods or classes to outside when queried with reflection. If there were no reflection, we would not need annotations at the first place.
Reflection is seeing and running java with java. Why is this needed is related to dependency inversion or inversion of control. Of course, we should ask if there is a reason for DI and IOC to exist. Then we can probably say that we can provide the infrastructure in the framework and let people write their code for the framework to execute. Then we may ask why they write frameworks. We should probably ask this to framework developers :) In general, we can say that they are written to standardize the codes and make the development easier with pre-built structures.
The design patterns is completely independent of Java. But if you are developing java, you should see how design patterns are implemented in java. This subject is also a bit about vision. For example, if i talk about "adapter", which is a concept related to electrical appliances, you automatically picture some electronic part that is complex on the inside but simple from the outside. This way, we can easily define some device whose details may vary but main features and functions are clear. This same logic applies to design patterns. It offers a guide to everyone which is understood the same way by everyone.
I think this is a bit extra, but it is a useful for your programming vision. We can take a look at the thread class in java and runnable and callable logic, without going into much detail. Threads are created for 2 reasons. Either to divide the process into parallel operations for performance purposes or to be able to carry out more than one job at the same time. They look similar in the end, but one of them requires some wait and notify logic, and the other creates separate operations working independently. I mean, there are details of course, but I think it is enough to be able to understand how servers are running on threads.
A note here: The computer engineering concepts like data structures, algorithms, operating systems and computer networks are vital to know. Without knowing these, it's like trying to be a driver and drive a race car without knowing anything about the engine.
If you are connecting to the database with Java, your path will definitely cross with JDBC. I saved the database part for later to keep on track here. At this point, one should know that jdbc is a standard, that it has a JSR equivalent and these JSRs change a lot in our java life. Because there are only 3 steps to be done to operate on the database with JDBC. Open the connection, create the statement and run the required query or execute method. If present, read the resultset and close the connection. But the real deal is to know how JDBC can be used in different databases and why such standardization is created. For example, how come the concrete class methods are activated even though we call interface methods in the JDBC codes?
First let me say that i'm not taking SOAP services seriously. I think soap services will lead you to monolithic applications. Therefore, if you ask whether soap services can be consumed with java, yes, but I would not do it.
At this point, we are dealing with questions like what is a web application, what is Tomcat or Jboss or Glassfish. Because we are not making desktop applications, we access our application over the web. Therefore, it is necessary to look at how to present and access a web application with java. Even though restful service logic is easy to understand, it has quite a complicated infrastructure in java. Unfortunately, java is generally a complex language. I'm usually starting by asking this question in my training: How can you run a java method on my computer from your own computer?
In order understand this java web system, you have to be able to answer questions like what is a network, what are OSI layers, what is an IP and port, what is a server and servlet, what is request and response. Then you will think about what does all this have to do with reflection. After these concepts are understood, the restful services will be easy to grasp. Maybe you already know what a restful service is, since you're reading this post. There are libraries like jersey or resteasy or huge frameworks like jakartaee or spring framework in java to let you build and run restful services.
At this point, you may ask whether you are interested in java and frameworks. For example, you can write restful services with just jersey and run it on glassfish or payara. This way your backend is ready and you can put a react web app or a mobile app on the frontend. If you want to continue, JakartaEE or Spring framework options are available. In this case Spring Framework would probably be your choice, since it is popular. Let me write both ways anyway. I'm mostly developing the Spring framework, but I've also tinkered with Jakarta and wrote a blog post about them. You can check it out if you wish.
If you want to use a framework with java, but the spring framework seems so complex to you, you can dive into JakartaEE and EJB. The corporate java applications of early times can now be developed in a more understandable way. Of course, concepts like service registration or resilience are not pre-built and available in Jakarta, like in Spring Cloud. So developing a microservice application doesn't seem much meaningful yet. But you can designed a nice system by putting Jakarta service behind a load balancing system.
If you want to use JakartaEE, formerly known as JavaEE, you need to look for the specifications in Jakarta. For example, you need to search for features related to security, bean injection or JPA. And you need to be able to answer the questions like what is a bean, how it exists, how it is injected and why this whole system (IOC) exists.
In the past, there was no spring, the servers were full of XML files. Now the spring framework is out and helping us with both dependency injection and inversion of control. At this point, you must focus on how you can use the spring framework and what it has to offer. You don't have to know the background codes or logic that much, but you need to get to know it in order to use it correctly. What does unsatisfieddependencyinjection mean and why it may occur?. Remember that the Spring framework is actually built on top of javaee. When you look at a stack trace output, you will see it is going through jakarta servlet. You need to be able to understand these stack traces.
Spring framework is has xml configuration or java configuration with beans. There are projects in spring, called spring modules. Like MVC, JDBC, Security ..etc. Spring framework integrates itself into certain technologies or technologies integrate themselves into spring. You must understand this logic and the workflow. Otherwise, the codes you write are just copy-paste. At this stage, you do not need algorithms knowledge to use the spring framework, you can use spring even you just memorize codes. However, when there is a problem or a mistake, it is not easy to find out where did you make a mistake.
At this point, after working with spring or jakarta, I strongly recommend that you go to Tomcat 's website and look at its definition there. There is an expression there that roughly says it is a servlet implementation. It is necessary to understand what that definition is trying to say. This is only possible after working with spring framework or jakarta for a long time :)
The first question you need to answer when we are talking about spring boot is why does spring boot exist? Because if you can't see the necessity of spring boot, you haven't dealt with the spring framework enough. In fact, when you had enough of spring 's constant configuration needs and underlying weird connections, spring boot appears to be an autoconfiguration paradise. After seeing this requirement, you can get an MRI of the system, which is built on 70 lines of stack trace, instead of seeing it as a magic trick. At this point, the level of abstraction becomes very high.
I think the most important aspect of spring boot is autoconfiguration and what is autoconfigured. Because you can find many code examples on the internet and try them. Data JPA works nice and of course JDBC also works, actuator and internationalization helps a lot, can be easily integrated with swagger. I would like to use these to get better at spring boot skills. After this, you can go further and try to understand how to create microservices with spring cloud.
The backend is finished i think. I say it is finished in 30 minutes, for you it may have been months :) At this point, it is necessary to decide how will you develop a frontend. Will you use a completely independent javascript framework, like react angular vue, or will you make the project with MVC and render the interface in the backend and send it to frontend? Of course, the decision depends on your project and your technical competence and abilities. It's not realistic for me to talk about the frontend part, since i'm actually a backend developer, but I'll write as far as i know.
In MVC projects, Thymeleaf and JSP (JSF can also be included) is created by java on the server side, rendered and sent to the frontend, which is the browser. You create an MVC project instead of a restful service. Thymeleaf mostly seems to be integrated into Spring Framework but it works with Jakarta. JSP seems to be integrated in Jakarta since they are bound by legacy, but it works with spring too. There to are very similar and there are alternatives too, but these are the most popular ones.
These technologies are dynamic screens rendered by the servlet in java. For example, things that should not be visible on the screen according to security criteria, can be hidden. Lists can dynamically be loaded with loops. Forms can be submitted and transmitted to servlets and ...etc. If you wish, you can even add pure javascript or jquery in these pages. But generally these pages are static in nature and dynamic in their generation. Since they have security integrations, i think they can be used in any large system production environment.
If you are going to write a separate application for the frontend and connect to your backend with the restful service, you should first understand javascript. Because we don't write static HTML pages like we used to and dynamic pages work with javascript. If you are going to be backend focused fullstack developer, you don't need to know javascript deeply. But frameworks like react or angular are based on javascript, so you will have to understand some concepts of javascript. We have questions like what is a function, is javascript object oriented, how to manage data and events or their results ...etc.
There are many JS frameworks built on top of javascript, but if you do not want to dive into that rabbit hole, JQuery is a good option as a javascript library. It has everything you need, from animations to changing css, from creating dynamic components to ajax requests. But the codes you write can be a bit bulky compared to framework codes. At this point, a decision needs to be made, in it or not? Because next comes JS frameworks.
Reactjs, angular and vuejs are most commonly used frameworks. Since i am not an expert in frontend i don't have detailed or extensive knowledge. Recently NextJS is also starting to become a bit popular. As far as i know, Angular is advanced but seems complex. VueJS is simple, but its support is limited and it seems hard to find examples. Reactjs kind of sit right in the middle. It mostly focuses on component design and is not too complex and has a large user base. Of course, i recommend that you use these frameworks with typescript if possible. It is difficult to drop the idea of object oriented programming logic after working in java. Typescript offers the structure most similar to OOP.
If you are wondering if i am going to talk about these, actually no :) These titles are not the barebones of fullstack development, but they will expand your fullstack development vision. Hibernate ORM, even though i dislike it, database object managing library, which replaces JDBC. It can be used easily with Spring and Jakarta. The persistancecontext needs to be understood very well here. And also, it is not easy to write the relationships between models with correct annotations here.
Writing unit tests is mostly easy in java applications with Junit. You can write and execute your tests with the help of AssertJ. Here, i assume you have learned how to use Maven somewhere along the way. Tests that are placed under the test folder are run automatically by maven. But at the end of the day, the easiest tests are written with Spring boot. Because the integration of the system is very powerful there. It's possible to write the DB layer test or MVC controllers test or the entire application tests.
Security is a very broad subject. You need to decide first how you will ensure security in the system. If you want to use username and password and login information and render screens dynamically according to security, there are infrastructures for your endpoints or MVC pages in both Jakarta and Spring. If you write a restful service, you usually use a token based system, like JWT, and integrate a JWT library of your choice into both Jakarta or Spring.
Docker is a subject that can be learned for extra credit. If you are familiar with virtual machines and virtualization concepts and have worked with Linux a little bit, it will not be very difficult to learn Docker. It is not a necessity, but it will definitely help you out.
You can also take a look at CI/CD concepts at this stage. It enables the automation of components like testing, building and deploying. You usually use extra tools for this, like Jenkins or Sonarcube. You can create a system that deploys the app to production right after you save it.
You will have to get into the databases one way or another. Nowadays they are divided into 2 main categories, relational and nosql. Among the relational ones, there are Oracle, MSSQL, MySql, PostgreSql are the well-known ones. As for Nosql, MongoDB, Couchbase, Redis are the ones that come into my mind. If you are using a relational database, you need to be able to answer these questions: What is a table, what is a view, what are constraints (primary key, foreign key, unique, control) used for and what is a view. Later, you will need to learn the SQL language to write some queries on your own that contain joins or group bys. If you are doing very complex work in your database or working with very large databases, you may have to learn SQL in detail.
Of course, it's a bit of a joke. This is the list of things you have to know or may need to know in order to be a self sufficient fullstack developer. It's a long road and a very long list, but rest assured, there is more after this. You'll probably have to know all of these topics in more detail on larger systems. If you want to try microservices, there is a huge world we call Spring Cloud waiting for you. In this case, SAGA and CQRS topics will emerge. RabbitMQ, Kafka or Redis can be used in these systems. From now on, you are mostly starting to learn and use these tools.
I think it is necessary to learn these topics thoroughly following this order. Because sometimes, 1 sentence you read in the spring boot documentation covers 4-5 days worth of information in the beginning stages. If you want to test if you are succeeded after this process, you can check 2 things. Are you getting lost inside the codes or application or the framework? Are you able to find your way around or inside or outside? These questions should be meaningful to you. Being an expert starts here. Also, see if you can bring some of these technologies or libraries together, like a mix and match. Are you confined to using certain combinations or codes you have learned or can you add more code or new ways on top of what you have seen or given or taught?
You can seek mentorship or trainings on this topic. The training of these subjects usually lasts approximately 3 months, 5 days a week in total. So I'd say minimum 10 weeks, but you can assume it is 15 weeks. When you code by yourself or with your friends or if you are a google learner, it is possible for you to study for 9 - 12 months. If these times seem exaggerated to you, this whole blog post may not mean much to you :) I hope this will be useful as a guide. See you at the next post :)
Leave a comment