When you were starting out how do you absorb information on books, tutorials and stuffs? on a clearer note, what do you do that helps you remember everything you read and understand how they really work?

There are times when I can absorb the information easily and recall them back easily when I need to use them on some projects. But sometimes even if I reread the text several times, I just can understand and remember specific stuffs and takes me ages just to figure out what I am supposed to do and supposed to use on the thing that I'm working on.

And to experienced programmers out there, do you still check the index,glossary and stuff often? (Documentations[F1] or whatever it may be for you) Because I find myself looking at it once, twice or more everytime I work with a project.

Thank you in advance.

Don't worry about it. It's impossible to know and remember everything, reading the documentation and other technical books is totally normal, and something you will do often, regardless of for how long you have been programming.

The way to make the knowledge your own is to use it, that is, just keep coding.

Continue to solve problems and get experience, and be more concerned with the broad strokes of how to solve problems and how computers and programming work in general, instead of with details like what parameters to send to a specific function in some API.

Then use documentation for the details of APIs and how to work with the platform and language you happen to have to use right now.

It's normal to have the documentation always at hand.

Yeah I agree. Don't bother too much about remembering every details - those you can look up.

What's more important is to be familiar with what's possible and what's not, what's new and what's old. Be familiar with typical architectural- and design patterns, with what technological alternatives you have and how they fit into your work. Stuff like that.

What I'm trying to say is that it's more important to have a good perspective than being able to recite a complicated function. The more you can write down / bookmark for future reference, the more your brain is free to think about more important stuff :)

Trying to remembering everything you read is what they had to do in the old days when there was no internet and you had to borrow the only available book from a friend who knew a guy related to someone living close to a library :D

I once took a class on doing taxes from the IRS. His rule was: "If you haven't looked it up in the last five minutes, just look it up again."

A measure of a programmer is not being able to write a complete program on a white board from memory. There may have been some changes to the API since you last used it. Or something you use all the time changed awhile ago, and now there is an easier way to do it or a better code example that has extra stuff in it you've left out.

When I start coding, I always bring up the documentation to whatever I'm using before I start using it. I've got MSDN, OpenGL, SDL, and a whole bunch of other stuff bookmarked waiting to be used. The more you learn to read the documentation, the better you get at deciphering what it is trying to say. Also, don't be afraid to download and link the source code for a library. You can always read the source code, and you know it's up to date.

What helps ME most is not just reading stuff... but working on an actual project and having to use/implement that stuff in it. Then, and only then, it will stick for certain... given we are talking about the solution to a problem I was fighting with for hours, the solution, once found, will be superglued into my memory :)

Just reading books is a very bad idea, at least for me. I usually read something (or parts of it), or watch a tutorial (or parts of it) when I need it, and try to implement what I learned next to it. If I just read it somewhere, and then a week later need it in a project, I am dead certain I will have to go back and re-read it, because in the meantime I only remember I read SOMETHING about it a week ago.

If I did something practical with it just next of reading it, it will still be present a week later.

That is what works for me, YMMV.

It feels to me like I have to write something in order to retain it in memory. I write down just about everything and then never look at what I wrote again. Maybe it's a whole "hands on" sort of thing.

Reading, watching, or listening just doesn't do it for me very well. I don't worry about memorizing something that I can look up easily enough. If I look something up enough times, I'll probably retain that info for awhile but, if I don't use it regularly, it's gone after awhile. Just make sure you have a source that's reliable and fast to get to.

And to experienced programmers out there, do you still check the index,glossary and stuff often?

Yes, all the time. I still go back to my college books for formulas, and read the API docs for whatever I am doing. Memorizing only helps, but is never required. Most stuff you only code once in a great while - like in your example: once per project.

For me it works too always do all exercises in books, bringing the stuff you've read to practice. Takes more time then just reading, but it helps me remembering and getting more experienced.

I don't have much to add to the above, but I agree that memorization is wildly overrated in programming (and most other fields as well). It's impressive to be able to rattle a variety of complicated things off from memory, but memorization is hard, time-consuming, and in the end you only get marginally (at best) faster code entry into whatever you're working on. On the other hand, learning to look things up efficiently gives you prompt access to everything which can be looked up (which is pretty much everything there is).

Keeping a well-organized collection of references is much better than trying to memorize.

Also, it helps to build a cheat sheet of some commonly used functions or such that you usually find yourself using.