if you Google: “How to read framework specific books”, you won’t find a tutorial on how to read these guys, but rather an endless list of “top 10 software development books”.
But how would you go about reading these books? How to choose the books that suits you at the right time of your growth and development of a software developer.
These are things that should be taken into account when starting to read software development books. Now you may know, there are certain books that are specifically designed to be read cover-to-cover (start-to-finish), and some that are easy to bounce around between other chapters.
Books on frameworks could be read cover-to-cover, but at the end, how well could you practically apply the stuff you have just read?
Framework specific books may seem to flow in a natural order, but often you should appeal to choose certain sections, and use the book as a reference.
In this article, I’ll be discussing the technique many novice software developers should know, and the more seasoned developers can to apply.
Framework specific books
When you’re learning a new framework it can be challenging and a bit intimidating to get one of the O’Reilly or Manning books and start to read it and not really understand what the author has written about.
“Man, I don’t get any of this”, this was me, about 6 months ago.
Often when starting out, you may not understand any of the concepts that seem foreign to you. This can be extremely overwhelming.
But overtime that feeling will fade and the things that you may not have understood will become clear and easy to grasp.
But what happened between the phase of not understanding to understanding? What did I do, and you may too have done to make sense of what’s going on?
As you mature and gather more knowledge and information, concepts that you may have not understood initially, will become clear because you have learned them by means of a different perspective.
This is essentially one aspect of the learning process, having different perspectives and you use those perspectives to mentally model your understanding of something.
Everyone has different model or views of the world. It is too what allows us to be more unique. A lot of these influence us and supplement how we shape our own reality.
But anyways, let’s get back to this post…
These types of books try to convey an understanding that is easier to grasp and form your own ideas about.
For example, learning the Spring framework was such a big undertaking for me. It’s such a large framework and there is so much to learn. There are a lot of great things that are incorporated into it that you could learn directly from; such as Design Patterns.
Dependency Injection is a design pattern and without knowing that, it would be more difficult to understand how the “magic” of it all works, because I wasn’t exposed or had understood other features of the Java programming language, like annotations.
Spring in Action, by Craig Walls attempts to explain the practical use of the Spring framework along with including practical examples. The book altogether serves as a guide or rather large tutorial to learning the Spring framework. The only problem is that this book is geared towards intermediate developers.
This book however doesn’t explicitly say that you should have knowledge of certain concepts and topics. That is a major problem that most software development books have.
As the market changes and as people who haven’t been programming for the past 4 or more years and only then learn a framework and knowing these concepts, is primarily what frameworks like Spring is focused on. Granted you should know the concepts and topics that it incorporates.
But the market is changing and new developers who have just started to code too have to know how to use frameworks and they don’t have years to spend to learn concepts and techniques before they touch their first real framework.
You are required but not advised to have a certain maturity in the field that you are working in. As a beginner software developer, it’s difficult to look at yourself and accurately measure your own maturity.
Well because your expertise may be in its infancy and you need to take great leaps and jumps without having a good grounding and foundational understanding.
This is a common problem self-taught software developers will face. Self-taught developers often don’t have external guidance and structure when learning. It’s difficult.
So how can you supplement this?
Well there are various techniques, but if you know me, well, I’m not going to cover them in this blog post. Let’s rather focus on the books for today.
Books vs the Docs?
Okay, so I want to learn this new framework, should I read one of the popular books on this framework or should I just head to the docs and online tutorials?
Man, this was a painful experience for me, choosing between a good but BIG book or over the massive online docs (which don’t seem to be that big anymore).
Books written on frameworks and the frameworks Docs both have their places.
Do you like baking? Well I certai… kind of. Anyways, I love cake, but I cannot for the life of me bake one. Well I could, but I never have tried.
Baking a cake can go in two directions. One, your mumma can guide you through all the steps and you are free to ask all the questions that you want. She’ll help you crack the eggs, mix the flour, add just enough milk, and probably tell you to use this type of coco instead of the other. At the end she’ll probably through something secret in there to bring out the flavour, two hours later (or a few weeks of reading), you have a cake, but you still can’t really bake one on your own.
The other appropriate is to look at the recipe, try to understand the ingredients and whip up a cake. The only downside to this is that your mumma isn’t there and your cake tastes like burnt toast after a hard day’s work.
Okay, so I think I have illustrated my point well enough. Having a good book that walks you through the steps and tries to explain something in a well organised and structured manner, often with examples that model real-world “problems” is often your best bet.
These books often introduce you to the concepts and ideas that the framework provides, and common how to references, with examples.
Documentation is doable, but you’re going to have a hard time. With documentation, you should have a different attitude to learning all together. You need to supplement the benefits of learning from a book, with addition of learning quicker and having more depth in understanding.
But don’t worry, we’ll go into more depth on both of these in the next sections.
How to choose “good” books
Choosing a good book is like choosing the right tool for the job. It can be difficult is you have only used a hammer before.
Simply Google, books on x framework. Choose the highest rated one on Amazon, read through the reviews and determine for yourself if this book is good. Often Amazon will offer a “look inside” feature were you can read the first couple of chapters.
You can also ask questions on Quora about the best book for x framework.
Purchase the book and you’re all set!
How to read these books
There are multiple ways to reading these type of technical books.
But here is a basic rundown of how you could read a book.
It should be obvious that you should read from the beginning of the book, as well, most books are structured that way.
Say hello to the book
Read a part, such as the first few pages of the first chapter, or the entire chapter from the book and try to understand it.
Write down notes on the stuff you don’t understand and ask yourself questions. For example, in Spring in Action, chapter 1 the author discusses the use of the dependency injection design pattern. If you don’t know what dependency injection is, make a note such as “learn about dependency injection.”
You should have a few questions that you are asking yourself of the things that you don’t understand.
In the next, next section we’ll go over how to answer these questions
Okay, so you may continue reading and you’re finding it more difficult to understand what the author has written about.
If it doesn’t make sense at all it means you’re missing an underlying understanding. This is quite a common pattern that all beginner software developers follow. Or perhaps you’ll find yourself understanding things temporarily, but it’s just not sticking to your memory.
This is where the use of summaries come into play. Really, I suggest that you sign up to Evernote and start making summaries.
Summaries are going to help you organise your ideas and help you build a clearer picture of your understanding of the framework.
For example, I am learning Spring Security, I read a majority of the core parts of the documentation, it made sense to me. But to my surprise, I had a lot of questions. What does this annotation do? What’s the difference between this and this? What does this class do again?
I am familiar with the Spring Security framework, but after trying to apply and implement it, I found that I had forgotten what a lot of the stuff meant.
This is completely natural, don’t be discouraged if you are forgetting the stuff that you are learning.
The key is to make note of everything that you are revising.
For example there is a special class in Spring Security called SecurityContextHolder. The spring.io docs define this as “Stores details on the present security context and the user principle”.
Well just by the nature of how people write compared to how they think a user will interpret this information, to how actually the user interprets this information, information is often left out.
There’s actually more to this special Spring Security class, and I won’t go into detail for the sake of this article, but you’ll need to remember multiple definitions that form an idea.
If you were to Google this Spring Security class, another definition on say, Stackoverflow will come up and it will just make perfect sense, well because it was phrased a bit differently or approached with a different perspective.
This is why note taking is important. Your brain can’t store all these details in its “context”, and trying to retain your knowledge while stuffing more in by reading and understanding is going to mutter everything up and you’ll find yourself having a hard time reading and comprehending information after a period of time (this is referred to metal-fatigue).
So again, just write down the details and take those off your mind, because you’re going to forget them anyways, and allow yourself to have the knowledge of a known-unknown, where you know about something, but not to clear on how it works (for the time being).
Don’t worry about the details for now, the most important part is to get a greater surface-level understanding and know about the common things, that are going to be useful later.
Again, this well organised summary will help you draw a picture that you can reflect on and understand.
Okay, so back to the book part of this blog post.
Remember all those questions you wrote down and didn’t understand? This is where you are going to answer those questions on your own.
There is no point going back to the book and rereading chapter 2, three times, hoping that you missed something and wanting it to click for you. It won’t work that way. For some people, the book may be enough and it just clicks for them, others, they need to revise and gather other people’s perspectives in order to understand something.
Remember my question was, “learn about dependency injection”. It should rather be refactored to ask, “What is dependency injection and how does it work?”
You can go and Google this and read a few articles out there that explain it well. You can then form a clearer understanding on what it is, and somewhat how it works.
It won’t hurt if you can find a tutorial on how to implement dependency injection yourself, because it is a Design Pattern. But if you don’t that’s cool. Just don’t run down the rabbit hole (like I did), by trying to learn the Design Patterns. It takes too long, and you shouldn’t be focusing on that just yet.
Okay, so you have come back and understand how dependency injection works. You may too have picked up on Inversion of Control (if you had read Martin Fowler’s, Injection article) – but that isn’t important.
Okay, now it’s time to go back to the book and reread through the stuff that you didn’t understand at first.
Does it make sense? Can you easily follow along by implementing the code examples and hopefully going out of your way to play and expand those examples?
If not, that’s fine. You just need to do some more work. Hit up Google and search the topic that is part of the book that you’re having trouble with.
“Spring dependency injection explained”, read a few articles from there and revise.
Do this until you understand the part that you’re stuck on well enough.
Another key aspect to reading a framework specific book is not to read the entire book. I know it’s so much more tempting and easier to just let yourself get away with reading and not actually doing any work, but be honest with yourself, how much are you actually learning?
I know for myself because I would try to read a book cover-to-cover, uncovering unkown-unkowns but forgetting a lot of what I was reading.
How you should actually read one of these books is by appealing to specific sections you’re interested in.
I suppose the first few chapters, or the first chapter is essential, it most likely covers what the framework is about. Take note of these core aspects, this is essentially what the framework involves.
Try as much as possible to cut out the extra fat of the framework that you won’t be using. Again, you won’t be able to and shouldn’t learn the entire framework all at once. This is just going to frustrate you tremendously.
Once you have the core parts noted, it’s time to put down the book and choose which ones appeal to you most. I want to learn X so I can do Y with each component. That should be your motive, not because “well it’s part of the framework, so I suppose I should learn it.” No! This is really bad!
Hey, if you want to be able to create your own learning plan, I’d suggest that you checkout my previous blog post on doing just that.
Okay so once you have the that taken care of, it’s time to use the book as a reference to what you are going to learn.
So the first item on your nice compiled list is to learn X. This had been for me spring-core.
Turn to those pages of the book and start reading, create summaries of the things that you are reading, and so on and so on. (I have already discussed this above).
Only use the book as a reference, really, I want to save you a lot of frustration. I know it’s very tempting to read the whole book, I have done this, but you’ll be saving yourself a lot of effort if you don’t.
Just to quickly summarise, because I know some of you are going to forget this.
- Look at the surface of the framework, this is usually covered in the first chapter.
- Cherry-pick the parts that are appealing to you and you know you’ll be using
- Use the book as a reference, don’t just read the book.
How to read documentation
Ah man! Now I have to write the other half of this blog post and it’s already Wednesday.
Anyways, I suppose I should get to it!
Okay, so I already told you of the benefits of reading a book and the documentation. Both have their places and you can certainly choose from either.
You should know that most books are quite large, sometimes the word count can double compared to the docs, or it can offer a summarised and compressed version of the docs. It’s really up to the book to do that.
I must say, I do learn a lot quicker by reading a framework’s documentation. It’s concise and gets to the point.
Okay Adrian, that’s great and all, but how do I read the documentation? Have you seen the size of some of those things?
Calm down, it isn’t so bad. In a matter of fact, it isn’t that different from reading that book you chose.
You may look at the documentation and feel very overwhelmed, but give it time (like everything else) and that overwhelming feeling will eventually fade.
Like the book is structured, so as the documentation might be (well if it’s well written), there will be an introduction heading, discussing the what the framework is about, how it basically works, some of the core components it involves and so one. This is the same as the first chapter of the book I had written about earlier. You use the same process that I outlined too, read over the intro to grasp the framework, create a note and a basic summary, ask yourself questions and appeal to the sections that interest you.
That that’ll all said and done, is there anything else you should know about?
Well of course there is! What else wouldn’t you want to learn??
Well I had a problem just this week. I am learning Spring Security and for the life of me couldn’t figure out how the Java configuration worked. The documentation only covered the XML based configuration, which was all nice and dandy, but I’m not using XML, I’m using Java configuration!
I rushed to Google: “Help me with Spring security! What does HttpSecurity Java config mean?” And Google was like, “I’ve got niks for you!”
“Oh no!” I cried! How could I possibly learn how the Java configuration worked if there is no documentation or Google to come and sweep me off my feet to save the day.
I felt like a damsel in distress! But I soon realised, hey, I don’t need no documentation in shining armour or some article tell me what to do! So I picked up my sword and headed straight towards the dragon’s den – to fight my way through it!
In the next section, I’ll cover how to learn from reading the source code.
Familiarizing yourself with code
It wouldn’t suggest this to be a default option for novice programmers, as it’s more challenging. But often at times you may just want to familiarise yourself with the framework’s codebase that you are learning.
Spring Security is open source, and I can open up the JAR file with my IDE and look at the packages and class files. It’s good to familiarise yourself with how some internal things work, and what classes are available to you so you can code against them.
I was really struggling to figure out how the HttpSecurity class in Spring Security was functioning. So I dug around and found it, studied the code for a few hours and then, it finally clicked! Ah ha! I get it now!
If you’re reading the documentation of a specific framework, this can be useful. Reading the Spring Security docs, well, it’s kind of difficult because there are just somethings I didn’t understand. Once I dug around with the source code and found the class files that were mentioned in the documentation, I could then get a better understanding for myself.
This too is a very useful approach to learning a framework. When reading the documentation on a specific class, I’d recommend that you find that class in the source code and read the documentation along with it.
Especially if there are examples and they don’t even apply to you, write them out. Just by the act of writing will allow you to retain the knowledge you have just gained a lot easier.
One last thing I want to mention before I wrap up here is another defining difference between the docs and a good book. While learning Spring Security this week, I refereed to the docs and learned how the framework actually works, and what is available.
I then turned back to the book and reread the Spring Security chapter, just to clarify the stuff I had been learning. This is useful as having multiple perspectives will help you retain a greater understanding of something.
I suppose it’s one of those sections I that I realise I forgot to add but it’s Friday, I should really be focusing on finishing up and thumbnail part of this blog post.
You need to have a good example application a long your side as another reference to learning. JHIpster, which is a Spring and Angular specific “application” (well it’s a project-generator based application) includes Spring Security configuration. I find this really useful to studying the Spring Security config.
If you’re learning Angular (Angular 2+) for example, look at someones existing Angular project and try to understand what’s going on and why it is written that way.
For example, the look at existing service components, why are they there and how they are written. Take this existing project and rewrite it, and follow the docs of course. I found this as a great way to learn.
There is no shame in rewriting an application. You’ll often ask a lot of questions, like why did the developer use a parallel array instead of a Map (that’s a really obvious one, but you get the point) and correct it to your liking. You’ll often have a lot of these. This is again key to learning!
Rewriting an application is often easier because you won’t have to come up with the project outline or specification.
But if you’re looking at an existing project and don’t understand anything, it’s then time to go back to the docs or your book and spend some time on that instead.
What you shouldn’t be doing
Man, if only I knew about this section when I first started teaching myself, I would have saved myself a world of pain.
Learning how to learn is a broad topic, I have covered this in many previous blog posts. But learning a framework is just a little different on its own.
There are somethings that you shouldn’t do and somethings that you should. You can’t learn everything at once and hope for the best.
I used to try and learn by just forcing myself to read entire documentation notes, and nothing clicked.
What you need is a good foundation understanding, of the entire landscape. This too takes time, but be patient.
Give it time
In the past I tried to learn Spring Security and it just never clicked for me, even though I spend a lot of time trying to learn it, I couldn’t figure it out. This again, goes back to the maturity section mentioned above.
Currently this week I said to myself that I am going to learn the Spring Security framework. Yes, it was difficult at first, but I took it slowly and patiently. I give it a lot of time and made it one of my priorities to learn. I have spent about 6 hours so far learning it and it is going well. I finally (fist-pump) understand how to use it because I had multiple of those “ahh ha”, or “I get it now” moments where it just clicks.
You too need to learn to give things time. Even though you may feel that it just doesn’t make any sense, it eventually will.
Don’t study a section and move on because you don’t understand it. No, figure the first section out that you are struggling with (using the approaches that are mentioned in this article), because it won’t magically reveal itself in the next section. Again, use the techniques I mentioned in this article.
Especially learning how to learn also takes time. When I first started this year learning software development with Java, I didn’t know what I was doing and everything I was trying to study had no structure and nothing really made any sense. I felt overwhelmed and frustrated.
If you’re just a novice guy or girl, it’s fine, just keep working on it and one day it will click for you, like it did for me.
The worst thing you can do is give up and no longer process and learn. You’re constantly going to do that throughout your career.