Should I memorize it all?

Question

IT education

Question for experienced programmers. I just learned Python and took up the study of the Django framework and during the study I realized that a lot of small details from what I study disappear in my memory, for example: you need to create a model for the database, and for this you need a class that another class imported from django files should inherit and I remember all this, I remember how fields should be written and so on, but things like modules that need to be imported, specially named mandatory methods, functions that need to be written in certain places are forgotten , required arguments and. etc., all the names of what I indicated are forgotten after a day of non-use, unless, of course, I keep it in my head all day long. Attention question: should it be like this and you just need to practice and all this will freeze in your memory by itself, or do you still have to strain hard and memorize all this, or is the saying still appropriate here: "An engineer should not know everything, he must know where to look for everything"? Or whatever. In general, I'm waiting for answers.

Answer 1

Google to the rescue, as they say, a programmer is a person who knows how to google. It's impossible to remember everything. If you often write and use, knowledge is deposited. If you have not done something for a long time, sometimes even trivial things are forgotten.

Answer 2

should it be like this and you just need to practice and all this will freeze in your memory by itself, or do you still have to strain hard and memorize all this, or is the saying still appropriate here: "An engineer should not know everything, he must know where to look for everything"?

I'll tell you from my practice:
I had about the same problem with entity declarations in NHibernate, controllers in aspnet, and components in react. When I needed to add something new, I went to the old code and copied all this binding.
Sometimes I tried to write without copy-paste - auto-completion and auto-import helped a lot.
Now I’m already writing quietly without copying existing code, although to save time it’s worth adding a template to your ide.
In general, no need to grind. From frequent practice, you will remember everything yourself, or you will find another, more effective way of writing.

Answer 3

I’ll tell you from my practice:
In principle, my memory has always been “leaky”, no matter how much I train with literature, vitamins and other things, everything works fine for associations, but after a week, a month, remembering a template moment that you don’t use so often is not at all goes to the head.
Therefore, I found an excellent life hack for myself - documentation and snippets. An example of what it
looks like:
https://github.com/harryheman/JavaScript-Total/blo...
information - which is then easily googled.

Answer 4

no - this is not a school where you have to memorize verse. But it was necessary to "manage" at least 1 time. When you master something once, then the second time you already "remember", and this process is usually many times faster.
And in order to remember even more, I personally remember certain details:
1) You have already done thing "x" in project "x"
2) In Project x you keep a notebook with comments, mini-documentation for you or in the very bottom lines write examples.
- (approximate solution) - also a very good solution, but I personally am too lazy for such a thing to spend so much time on it)))
3) The next time you do something, all you need to remember is the fact that you did them already in that project "x",
To summarize everything - things that you use one-time, you won’t remember or memorize in any way. Just write them down and remember not how they are made, but where they are. This is a matter of organization, not cramming.

Answer 5

You won't remember what you don't use every day for a long time. You can thoroughly remember only things that you thoroughly understand, and then on condition that the thing is quite simple in terms of the things and concepts contained in it. For example recursion. I remember when I did not yet know what it was and how it works - not a function that calls itself, but about the fact that there is a call stack and so on and so forth. For two days I could not understand where the function takes the parameters for the next call, where the parameters come from when returning. I dug for a long time, experimented, then finally found out about the call stack. After that thorough ditching of this topic, it is always in my head, as a skill in riding a bike that cannot be lost. Only now recursion is a rather simple moment in programming in its content. Essentially, you need to know that recursion needs a base case, that there is a call stack, that it is a function that calls itself. It's pretty easy to keep that in mind. But hundreds of django settings, millions of functions, patterns, names - alas. To do this, they came up with an autocomplete in the IDE, for this they came up with Google. In real conditions, everyone doesn’t give a damn how much and what you google, at least google every line (well, I’m exaggerating, of course, if you google each line, the development time will increase exponentially). It is enough to know that the function or setting exists and that it is needed. Parts can be replenished if necessary from the docks. Well, where something needs to be written directly by the framework itself, in any case, remember if this is done often But hundreds of django settings, millions of functions, patterns, names - alas. To do this, they came up with an autocomplete in the IDE, for this they came up with Google. In real conditions, everyone doesn’t give a damn how much and what you google, at least google every line (well, I’m exaggerating, of course, if you google each line, the development time will increase exponentially). It is enough to know that the function or setting exists and that it is needed. Parts can be replenished if necessary from the docks. Well, where something needs to be written directly by the framework itself, in any case, remember if this is done often But hundreds of django settings, millions of functions, patterns, names - alas. To do this, they came up with an autocomplete in the IDE, for this they came up with Google. In real conditions, everyone doesn’t give a damn how much and what you google, at least google every line (well, I’m exaggerating, of course, if you google each line, the development time will increase exponentially). It is enough to know that the function or setting exists and that it is needed. Parts can be replenished if necessary from the docks. Well, where something needs to be written directly by the framework itself, in any case, remember if this is done often if you google each line, the development time will increase exponentially). It is enough to know that the function or setting exists and that it is needed. Parts can be replenished if necessary from the docks. Well, where something needs to be written directly by the framework itself, in any case, remember if this is done often if you google each line, the development time will increase exponentially). It is enough to know that the function or setting exists and that it is needed. Parts can be replenished if necessary from the docks. Well, where something needs to be written directly by the framework itself, in any case, remember if this is done often

you need to create a model for the database, and for this you need a class that must inherit another class imported from django files

What you need to inherit your model from the base model, you will remember very quickly, since these are repetitive things.

Answer 6

Practice, practice, practice. Forget a hundred times, remember 101 times. Well, google, without it in any way.