Hi! Today we'll talk about a Java developer's path of growth and what he or she must know to be in demand. In an interview, any developer might grill the job candidate. For example, they may start asking questions about specific topics that they have encountered in their current project. But not knowing everything is normal. The fact that you can't answer some questions is also normal. As a general rule, every Java programmer must have a basic understanding of software development. So let's take a look at what is considered "basic".
You should put this in the first place, so you can understand what Spring is — all about Spring containers, beans, DI, IoC, and so on. To understand the very philosophy of using Spring, so to speak. Your further study of Spring frameworks will build on top of this base. Perhaps you should create your own small application into which you can gradually incorporate all the newly learned technologies.
Earlier we mentioned JDBC as a technology for creating a database connection. In general, "naked" use of the technology can no longer be found in projects, so you may conclude that learning JDBC is not necessary. This is not quite the right attitude.
By exploring naked (direct) use of JDBC, you can see the technology at a lower level and understand its problems and shortcomings. Then when you start learning Spring JDBC, you will realize what exactly this framework improves, optimizes, and hides.
Analogous to the situation with naked JDBC, this framework leverages an existing technology, in this case, Hibernate. If you consider using Hibernate without Spring, you will definitely realize the benefits that Spring Hibernate offers.
Earlier we talked about JPA and mentioned that it is only a specification, though it has various implementations. Among these implementations, Hibernate comes closest to the ideal.
Spring has its own ideal JPA implementation that uses Hibernate under the hood. It is as close as possible to the JPA specification's ideal.
It is called Spring JPA. In a word, it greatly simplifies database access.
You can only learn JPA without learning JDBC, Hibernate, Spring JDBC, or Spring Hibernate. But if you take this approach, your knowledge of how to connect to a database will be very superficial.
This technology makes it possible to display our application's web interface to users and facilitate communication between the interface and the rest of the application. The technology can also be used without display when you have an application that is responsible for handling the display and you're interacting with the application using RESTful technology.
In order to better soak up information about Spring, in addition to articles and YouTube lectures, you can read several books. I really liked the book "Spring in Action" by Craig Walls. I advise you to read the 6th version, if you know English well.
Another great book on Spring is "Spring 5 for the Professionals". It's more dense. More like a reference that is more valuable to keep close at hand than to read cover to cover.
This technology greatly simplifies the use of Spring. I didn't put it at the end of the list on a whim. Indeed, it does hide a lot under the hood, and for someone unfamiliar with the vanilla Spring, many points may be unclear or incomprehensible.
First, for a better understanding of how Spring frameworks work, you should use regular Spring, and then pick up all the higher benefits of using Spring Boot.
I also recommend that you familiarize yourself with Spring Security and Spring AOP. But unlike the technologies above, deep knowledge of these two is not needed just yet.
This technology is not for beginners. At interviews, junior devs won't be asked about them (except one superficial question, perhaps). Read an overview of what these technologies are and the principles behind their work.
In this article, I have repeatedly mentioned reading books. On the one hand, this isn't mandatory. You can become a programmer without reading a single book, gaining all the required knowledge from online articles and training videos.
On the other hand, in the job market, competition among novice developers is high at present, which raises the bar for what a beginner needs to know. So, the more you know, the faster you will find your first job by impressing the interviewer with your level of knowledge.
Thanks everyone, and may Java be with you.
1. Basic algorithmsThe first thing to tackle when starting to learn programming (not just Java) is to understand the basics. For example, algorithms. There are an infinite number of them, and you shouldn't kill entire years of your life trying to learn as many algorithms as possible: most of them won't be useful to you. You can get the necessary minimum of knowledge from the book "Grokking Algorithms". This is enough to get you started, but if you want, you can learn from the book "Structures and Algorithms" or "Algorithms in Java" by Robert Sedgewick and Kevin Wayne. I also recommend that you improve your knowledge of computer science basics. This can be done with Harvard CS50 course.
2. Java SyntaxAfter learning the basics of algorithms, we need to learn Java syntax. After all, we're all studying to become Java programmers here, right? The CodeGym course is perfect for this. As you perform countless tasks, you will get your hands on Java syntax and then, without much hesitation, you will write/read Java code as if it were your native language. CodeGym is practice, but beyond that, you also need to look at the theory to understand what you are doing. To do this, you can read books. For example, one of the following:
- "Head First Java",
- "Java for Dummies" by Barry Bird;
- "Java: A Beginner's Guide" by Herbert Schildt.
- "Thinking in Java," Bruce Eckel;
- "Effective Java" by Joshua Bloch;
- "Java: The Complete Reference" by Herbert Schildt.
3. Design patternsDesign patterns are certain repeatable patterns that solve problems in frequently encountered contexts. They include basic, simple patterns that every self-respecting programmer should know. To understand this topic, grab the book "Head First Design Patterns". It explains the basic design patterns in an accessible way. But the book talks a lot about Java, so when you consume this book you'll also need fluency in this programming language. For a deeper dive into patterns, you can also read "Design Patterns: Elements of Reusable Object-Oriented Software" from the Gang of Four (Editor's note: the Gang of Four is a team of authors that includes Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.). Once you've studied this topic, you'll begin to see patterns virtually everywhere in your code. Pay attention to this, especially to the patterns used in Spring, since this is a popular interview question.
4. Programming paradigms. Code cleanlinessBesides the standard design patterns, there are various principles and paradigms to be aware of (SOLID, GRASP). You also need to keep your code clean and readable. For everything, you need to know about this topic, see Clean Code by Robert Martin, or check out "Code Complete" by Steve McConnell.
5. SQLOur next step is to study a language for relational databases — SQL. Databases are where the information (data) used by a web application is stored. A database consists of several tables (the address book on your phone is a simple example). Java developers are responsible not only for the Java application, but also the database that it interacts with and where it stores its data. In relational databases (which are the most common type), all interaction occurs through a special language called Structured Query Language, or SQL. To understand this topic, all you need to do is read one of these books:
- "Learning SQL" by Alan Beaulieu;
- "SQL" by Chris Fehily;
- "Head First SQL" by Lynn Beighley.