Is handwriting out code an efficient way to learn a programming language? [closed]

Is handwriting out code an efficient way to learn a programming language?

It is an efficient way to learn and remember fundamentals of the programming language. In addition, it helps and improves your understanding on how code works, you get better understanding of inner-workings.

It is also a good block against copy-paste trend which tends to have quick results for newbies without a clue what is happening in the code.

However, for productivity reasons having a set of tools is must. As example, you may accomplish your tasks n times faster with Visual Studio IDE than a Notepad++ and C# .NET compiler.

Thus, right set of tooling is very important factor for productivity.

More about dangers of copy-paste discussed in this post.

I always found it to be a complete waste of time. You have no idea whether that code compiles or does what you expect, and measuring what you expect to work against reality, and then researching why the two might be different, is how we learn things.

When I was learning I kept detailed hand-written notes of common library functions, but then somebody invented something called the internet and all hell broke loose. Libraries are sometimes updated faster than my ability to write so my notes often got stale very quickly, not to mention that you can search online documentation but not handwritten notes.

Of course, everyone learns differently so perhaps this is the most effective method for you - your mileage may vary...

In my experience it's not that productive at all. For example, it's very hard to insert a blank like between two existing lines of code when it's written on paper!

However, it's not uncommon during an interview to be asked to write out code on paper in order to answer a question. I also make sure I take a pencil with an eraser on top, as this can be tough when you've only got a pen!

I think it has pretty limited benefit. It may assist in learning the syntax of the language, but once you start actually using the language itself, writing code you can't execute doesn't help much. It's probably a useful exercise for the first couple of weeks of an introductory course, but after that I think you'll see more benefit from running your code through the compiler (or at least a syntax-checker).

I will note that when following a tutorial, typing out the code (rather than downloading it or copy/pasting it) is a better way to learn. It tends to generate more thought about what your typing. And every time you misread the code (and thus, trigger an error), it forces you to put in extra work. You can improve learning even further by never looking at the code you are copying while you type it. Aversion to wasted effort is a memory enhancer.

I completely second what Yusubov says: it might be a good way to teach you the fundamentals of a language. I would even say: it might contribute to teaching you the fundamentals of programming.

What I wanted to add here is that it helps make a clear distinction between the language you're learning and the tools you're using. Working in a modern environment doesn't necessarily make this distinction very clear.

Is handwriting code an efficient way of learning a programming language? Yes, it can contribute positively to learning the language in the early days. How productive is it? Not very much.

Being able to handwrite understandable code is an important skill for whiteboard meetings (explaining an alternate or better algorithm to the team, etc.)

Being able to write correct code without the compiler and unit tests to do the checks for you puts less of a load or dependency on those tools and their (theoretically imperfect and often many) holes in their coverage.

The main advantages of handwriting is it generally helps concentrate on what you are doing, so when you finally do the coding, you know exactly what you are doing. The downside is that it can be counter-productive. I find it better to handwrite algorithms and "type" the actual code.

For me, learning a new language also includes learning the environment you will be using it in.

And the best way for me to learn a new language is to actually program in it, and by that I mean actually program and run a small application, so I can see the results, not by trying to program on paper.

I think it's not about productivity, it trains programming mindset. Before a fairly easy problem (like count prime numbers in first n integers), 9 out of 10 students might think that they know the answer and start typing. But very likely, their solutions miss some edge-cases, or not the optimized way.

One of the benefit of writing code instead of typing is that it forces students to think before typing. It's easy to insert/delete a code line, but it isn't so easy to write between paper lines. Even if they do write between the lines, the imperfect writing gives hint about their imperfect approaches, which imply some space to improve.

As my comment above:

In my university time, there are 2 classes of fundamental programming. The class in which the professor requires students to write code to paper generally performs better to the other class (in a programming contest which uses real computer)

Of course, the above quote is only my observation, but it gives a hint about how it works.

Code examples

You cannot compile a piece of paper. Even if your teacher looked through your papers he may not find all the compile errors. A computer does this, now and everytime. Seeing your program function will make you feel that you have achieved something. You can see that what you write works!

If the code is for a throw away purpose - learning concepts and the like - there might be some truth to hand writing. But it could just aswell be written on a computer, speeding up your writing.

Documentation

If you're a programmer you'll be sitting in front of the computer most of the time. If you're sharing a code snippet with your colleagues you're better off sending it through chat. It will also ease your mind, to see your code built/running before sending it.

It's too hard to update/share hand written documentation. It will probably be outdated once it is printed.

Overall

You would repeat yourself by writing code on paper, as it would have to be copied to the computer at some point - thus violating the DRY principle. You write code once, and read it many times.