Is learning how to program like learning a foreign language?

Is learning how to program like learning a foreign language? Well, it’s a definite “yes and no” from me. I think many people oversimplify this. And then they say that their programmer friends think the same way to ‘prove the point’. Mostly I bite back the question of how many ‘real languages’ the programmer friends have learned or even learned to a native-like level. Because I think that there are some quite important differences.

Since I just read this brilliant article The Ancient Case Against Programming “Languages”
by Patrick J. Burns on Eidolon (Apr 24, 2017), I thought I could contribute some of my thoughts on the topic as well. They stem less from the interest in not losing funding for second language education, but rather from some of my own experiences in “second language programming education” or whatever one might call it – the act of learning programming (in your 20ies at earliest) after having learned multiple natural languages as a Humanist.

Elegant code reads like a human language

Of course, some elements in programming are like learning a real language. For instance, good code should ‘read’ like spoken language. If it sounds too ‘unnatural’, something’s wrong with your code. Or, at least, it’s not very elegant. Elegant code reads like a human language. Ok. But this is only at the surface. To a human. Not to the machine beneath it. After all, in the end the thing about programming is that it’s not a natural language. The ‘natural language looking part’ is only the face your code shows to you as a human. And it is a common opinion amongst programmers that you can’t write good code without understanding the machine. Well, maybe in web programming you can get away with it. But for anything and everything else, you don’t actually.

“It’s like learning a natural language in the way that you need to use it.”

Some people say “It’s like learning a natural language in the way that you need to use it. You can’t learn it theoretically.” Ok, agreed. In that respect, yes. You need a good reason for wanting to communicate and use the language (and actually end up doing it), if you ever want to get good. But this is true of any skill. Of course, you need practice. So is this really a criterion valid for the comparison between learning programming and learning a natural language? They’re both skills. And I think in this case, it’s more about both being a skill to be learned than the ‘language part’ which is their commonality.

A human language requires skills a computer language doesn’t and the other way round

In this discussion, it often happens that people mix up the general skill of programming and the programming language. Like I have mentioned multiple times before.

But the point is that, in my opinion, it’s the ‘algorithmic thinking’ and the specific skill in programming which is difficult with learning to program. The complexity doesn’t come from the language. After all, compared to a human language, computer languages are blatantly simplicistic. The difficult part is understanding algorithmic thinking, algorithms, data structures, having a genereal knowledge of how things work behind the scenes. This skill is not required in human language, I think. You can master you mother tongue (and a foreign language too, by the way) without ever looking up the grammar. You get a feeling for it. When have you ever mastered a (sufficiently complex) function from a library without looking up its arguments?!

No listening or spoken part about programming – communication functions differently

You only read programming languages. There is no spoken or listening part. This makes for a huge difference since this is the part lots of people have difficulty with, especially in attaining native-like level. Getting rid of accents is a never-ending endeavour. What does this compare to in programming?

You never stop learning a living language

Also, with a human language, you can never fully master it. Which is possible for a programming language, I would say. Of course, there always is room for improvement in general problem solving skills. But, for example, John Sonmez mentions in his book The Complete Software Developer’s Career Guide that after a solid amount of time of being a good full-time programmer, you do reach a ‘glass ceiling’ where he says that, essentially, all who have reached this point are virtually at the same skill level. This suggests to me that a natural language is more complex than programming even with the whole other skill set involved (other than the language itself which is quite obviously less complex). But of course in programming, you can get into many surrounding fields or topics which make sure it doesn’t get boring. Yet here, I really can’t see how natural languages and computer langauges are very much alike.

They are similar, however, in the way that they constantly evolve and you need to learn the new stuff regularly if you want to keep up. This development is maybe even a little bit faster and more challenging with programming languages.

It’s both easier and harder

In programming, you (can) get away with very little vocabulary and grammar. Bad style still compiles most times whereas in real-world situations, really bad style might cause you to not be understood by fellow humans. While it’s noted, of course, that humans usually try to interpret your utterings in a way to understand you when a compiler will just stop and complain something’s wrong. Hopefully with a helpful error message attached.

When judging people’s skills, always take into account (and don’t underestimate) the amount of hours they’ve invested getting to their current level

I feel that it’s quite common when talking about skills that we want to identify some people as geniuses. While I don’t say that there are no geniuses, my experience shows that you need to break down the information very carefully before you judge someone a genius. There are a lot less geniuses around than people want to make you think, especially in the land of Academica where everybody like to think of themselves as a genius.  A genius is someone who gets very good at multiple (!) very different skills with hardly any effort. This is, as far as I remember, a common (scientific) definition of highly intelligent people. Yet in everyday talk, we often assume high IQs in people who are extremly good in their field. But acutally, your general intelligence only gets proven by the ability of easily reaching this level of competence, very fast, in practically any given field (or at least multiple). Often, people hide the fact that they actually put in a lot of effort.

If somebody has spent 10x the hours you spent to learn something and is a bit better than you, is this really a sign for a genius? For perseverence and discipline maybe, but putting in more time and thus ending up being better is not a sign of extraordinary talent. By which I don’t want to minimize anything, I just think we should abstain from jumping to conclusions and generate an inflation of geniuses along the way. Because this actually destrocys what ‘excellence’ means: It’s the one who stands out from the crowd. Yes, the one. There can only be one best at anything. Excellence initiatives therefore really are quite a ridiculous concept, operating on the assumption you could have armies of excellent people. Not in the strict sense of the word, you can’t. Rant over.

What has this got to do with the subject of this blog?

Well, it appears to me that nowadays, we often think people with good programming skills are geniuses. And maybe they are. I’m not saying they can’t be. But I think that especially us in the Humanities should pay very careful attention that we don’t over-value programming skills and under-value our own. But saying programming languages and real languages are the same skill can easily end up in “real languages are inferior” or “skills in living languages are inferior to programming skills”. So I think it’s important to keep the distinction. After all, to a real programmer who understands the machine, it will be quite clear that, in fact, a programming language is really not like a natural language at all.

While this may appear to be simply splitting hairs over the word “language,” I would point out that the stakes over this distinction in educational policy are high. These policies, founded on the false equivalency that “(natural) language = (programming) language,” could result in reduced funding for secondary language programs and further chipping away at their already tenuous curricular footholds. Under this specious rhetoric of substitution, coding courses would be built on time, money, and students siphoned from traditional language programs. This is exactly against the spirit of the trivium. Grammar and logic are not mutually exclusive, but mutually beneficial. (Burns on Eidolon)

Another problem this lack of distinction might entail is, as Burns stresses, the potential loss of funding for language education, with argumentations along the lines of “learning programming and learning natural languages teach the same skill” which is absolutely not true. But in our tech-loving world today, I think there is a real danger of something like this happening in the future.

The term has clear roots in the the formal languages of mathematically minded logicians from Leibniz to Frege. Yet, in the earliest stages of what we would now call computer science, these instructions were referred to by a matrix of words such as calculus, system, assembly, scheme, plan, formula, and, sure enough, code. “Machine language” appears early, but widespread adoption of the word would take time. Certainly, by 1959, the development of COBOL, or Common Business-oriented Language by the Committee on Data Systems Languages (note the plural) suggests that this was the default term. The exact process of its popularization is difficult to trace. Noam Chomsky’s algorithmic “descriptions of language” clearly exerted influence, but it may also have been spurred on by Grace Hopper’s introduction of English keywords and syntax to computer programming as she sought to replace math-heavy commands. Hopper’s instincts were correct and coding has moved increasingly towards human-readable “languages.” ALGOLSNOBOLSQLTclHTML, and perhaps Perl— they all hide the victory of “language” in their acronymic ells, and it is this victory that has given policymakers license to exploit semantic slippage for their own curricular ends. (Burns on Eidolon)

Humanists’ special talent for living languages?

Another thing I’ve come to observe when teaching which is maybe a relief to Humanists trying to learn programming even though it’s a slow process for them. My friend the Noob always calls it ‘an adventure’. Which is a better way of putting it, I think. Learning something new is beautiful. Even when it hurts at times. So back to the argument:

Sometimes in my DH classes, I teach those brilliant programmers who are in their very early semesters and I’m awestruck. Until I hear them speak English that is. Then I’m awestruck too, but in a bad way. I often see this with people who went to Austrian HTL (Höhere Technische Lehranstalt). They leave this institution with an impressive knowledge in technology; if they were good students. So good, in fact, that I’m usually quite blown away as a self-taught programming Humanist.

But then I observe that the Humanist students who seemed quite untalented with programming are really good at English. And then I remember that learning a living language to a certain level of mastery just takes years. These are years they did not invest in learning how to program. But the programmer did. Yet they often aren’t as good with living language in general (punctuation, grammar, spelling, etc – let alone foreign languages). Many have difficulty expressing themselves in ways which serve to communicate with humans. Of course, there are exceptions. But the rule fits quite well for most. And this suggests to me, very strongly so, that programming and natural languages are in fact very different.

Also, another comforting thought for Humanists. Yes, I know it’s hard to acquire programming skills if you’ve never done anything of the like before you were 20 (or even older). And doing so beside your real work in the form of life-long learning. It’s just not the same thing as having all the time in the world to intensively learn a new skill at school. Learning completely new skills just gets more difficult with age. But you can learn new skills. Whereas it becomes less and less likely you’ll master a foreign (natural) language if you haven’t acquired one to a high level before you’re 20 where ‘language-learning window’ is still open. So this might be a consoling thought to end with 😉

So really, my point is that we should avoid subconsciously shifting our view of what ‘intelligence’ is to a completely digital and non-Humanist perspective. We should also avoid getting sucked into the idea that all programmers are geniuses or intellectually superior (thanks to popculture for that). Not at all to begrudge them the success but because #HumanitiesMatter too 😉 And also, if you’re feeling bad about yourself compared to a programmer, be sure to check if they still look as genius-y as they would like when you go check for certain flaws. So if you’re a Humanist and can’t program – don’t let people tell you you don’t have valuable skills.

I would be happy to hear your opinion on this matter,

until then,

best,

the Ninja

References

John Sonmez, The Complete Software Developer’s Career Guide, 2017.

The Ancient Case Against Programming “Languages” by Patrick J. Burns on Eidolon (Apr 24, 2017).

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Advertisements

I need a training progression for academia and programming

As some of you might know, I am currently a fellow, aka at my personal writing retreat at Wolfenbüttel. And I decided to combine this with some sort of a training camp for my bouldering progress because you do need to have some breaks from writing during the day anyway and I can’t always watch Bones or create CV templates. You might have been following some of my bouldering on epigrammetry, the blog, or epigrammetry, the Twitter.

 

Training progressions in sports

Also very few of you might know as well, I used to train a lot for long-distance running (10k) during my teens. So I know what training progressions are. I used to have detailled training plans, eating regimes, supplements to take and all that jazz. I stopped at some point because my immune system kept bullshitting me and as an ambitious person, I couldn’t take the idea of having to start from scratch after a half-year of being very sick and weak. I’d had it with having to arrange my whole life around my training. Yet the principles I’d learned over the course of the years, plus the high level of discipline required in those persuits, have helped me a lot during my early university studies.

 

Systematic progress needs training goals

Looking back now, I used to approach studying and my ‘university progress’ just like I would have had planned my training progression. And it worked. I was really productive, things were going well. For me, at the time, this consisted mostly of getting all the translation homework done, reading a lot of Latin and Greek (at least an hour every early morning before starting my day) and getting through all the classics. Because I was fucking motivated.

This might have been due to there being actual goals to be achieved daily which I could measure my progress on. Like the speed, and thus number of pages, I would get through during my early morning reading practice. Back then, by the way, I also used to combine physical exercise with mental workouts like I have taken up again for this summer’s ‘training camp’. It works quite well. I should probably continue with it back home.

 

How do you create a training progression for programming?

My problem is now: Over the years, I seem to have gotten out of the habit of approaching progress systematically. Or, well not exactly, but – let’s say – I follow academic learning goals with a lot less zeal ever since I got my degree. Which probably is the case for mostly everyone else. Because it’s quite a bit harder to find time and motivation for non-goal oriented learning after a hard day at work than when you had all the time in the world to study. I really envy my youger self for having all this time for learning. I love learning. But life-long learning isn’t exactly the same and doesn’t end after your degree, espeically not if you’re an early career scholar. Now I have a vague idea of some skills I want to improve in. But I am very good with training progressions and thus I know that the common advice ‘just program a lot’ or ‘do a private programming project’ just really is crap advice. Of course, it’s true. You just need a lot of practice. But there still are ways of approaching this effectively or ineffectively.

There are some good books out there which actually provide some learning progression. There is John Sonmez’s Software Dev Career Guide which is the single only thing close to a book providing a progression to systematically get better at programming. And, who would have thought, he is an athlete too. I always thought I was the only one who wanted a systematic training plan. But apparently, he felt that need, too. And for good reason. I have already complained many times about why people don’t approach learning like training and still expect to get reliable, constant results. With learning, this systematic training approach is called ‘curriculum’. In the post linked above, I mentioned that I thought online programming platforms were the answer.

 

Which tools or medium can actually provide curriculum?

At the moment, I am at the point where I have let those online trainings slip again, a long while ago already. As it has happened to me multiple times over the years. If I can deduce from experience, I am likely or restart eventually and go crazy at online programming workouts for a while, then drop it completely again. But what you really need is consistency and daily workout. Plus, I can’t just do the apps. I always have a lot of books to read as well, which is quite important to me so they can’t be neglected either. But then I often end up only spending half of the time I would want to spend, read the book or, if you want to call it that, finish my ‘reading time’ and get tired after that. Also, I should already be at work, so I skip the programing workout.

While something surely is better than nothing, I should probably focus more on the practial work if I want to make faster progress. But in programming, that’s different from bouldering. In bouldering, it’s easy to see which routes I am capable of doing or whether I nailed a particular route. Or count how many pushups and pullups I can do (not enough, I have to admit). So I can measure progress easily. But with programming, this just isn’t the case. And in addition to that, for bouldering, there are tons of youtube gurus with mulitple videos each on how to get over plateaus and make progress, what you can work on, etc.

 

Willpower alone isn’t enough

For programming, most of the advice isn’t too good in my opinion because it’s often too generic (“get a project”). Bouldering tips are concrete like “Perfect your flagging technique”. It’s easy to look up how you do that. It’s easy to notice when you’ve got it, physical feedback makes sure of that. So I decided I’ll have to look at my programming workouts the way I approach my pushups for now (they need to get done no matter what and no whining around). But it’s not really a solution to the problem to rely on willpower alone. Willpower alone will ultimately fail once you get stressed or anything comes up. And when that happens, I have a really hard time getting back into the routine. Which I hate. And then I hate myself for not managing to and then the vicious circle goes on. It’s really annoying.

 

We need curriculum for systematic and swift progress

Of course, even with a good curriculum or a training plan, there will still be plateaus. You will still get stuck. But a good curriculum can help you over that last edge of the boulder. It can help you re-gather yourself after a failure or after you’ve let it all slack for a few weeks.

So this subject also makes me think with regard to this blog, it’s all the more important that curriculum gets developped for learning advanced LaTeX, so a willing user can make rapid progress. Rapid progress is good. It keeps you motivated. Plateaus are really dangerous because the can make you lose motivation and give on up the goal alltogether. So let’s find ways of measuring progress and collecting tips of what you can do to actively and systematically improve if you’re willing to.

Step one probably is to get the people to shut up who sneer at systematic approaches like this one. “Learning to program just doesn’t work this way”, they repeat time and time again. Yet I think this is not true. Getting better at programming is like learning any other skill. There is a systematic approach to it and when we have a systematic progression and training goals, we can figure out the steps we need to take.

That was it for now,

best,

the Ninja

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Typesetting Code in LaTeX

Since I recently pulled a few all-nighters to prepare code slides to teach my students R and they were less than enthusiastic, I thought I’d use the opportunity to at least write up a post on how to display code in LaTeX for you guys. It focuses on displaying the code for teaching, writing tutorials and so on. So the integration of code in beamer will be dominant, or at least the example on which I demonstrate things. Of course, you can also use the tips to just display it in a ‘normal’ document.

When I thought about it, I realized there are actually so many ways of displaying code using LaTeX packages. So I’ll start with the most basic and then go on to the more advanced ones 😉  You can find the example document here on Overleaf. It uses the beautiful metropolis beamer theme, which is worth looking into as well.

code-listings1
Be sure to check out the template on Overleaf.

The \texttt{} command

This one isn’t a verbatim way to express code, but it will change the font to typewriter, so it ‘looks like code’. However, in these short bits of code, you will have to use escape sequences for reserved characters. Furthermore, it (shockingly!) is not natively included in beamer, so you have to add it yourself in the preamble if you want it (as demonstrated in the template). How can one write about code without over-using \texttt{}?

I make massive use of \texttt{} when ‘talking’ about code or, you know, writing explanatory text sequences. It is especially useful for bits of code where there is no excessive (or none at all) use of escape sequences. Then it is a really handy way to quickly typeset code. Once you have lots of reserved characters, you might be better of just using this next one.

The verbatim environment

This one really is a staple and pretty failsafe, but also doesn’t have code highlighting which you might want in most cases, apart from very short bits of code where highlighting isn’t important.

You can use verbatim as an environment for multiple lines of code which appear like a quote as a separate block in your text. In other cases, where you just want \texttt{} but without having to escape reserved characters, you might want to use the \verb|some code| command. You can use any characters as delimiters to denote beginng and end of code. To be more precise, a quote from the Overleaf site: “Any character, except letters and *, can be used as delimiter. ” So it can also be \verb+test+. The idea is that you can choose one which you will not need inside the code, as not to ‘confuse’ the enviroment.

A note about code in beamer

When you use code in beamer, make sure to always use the fragile option for the frames in question. This is necessary due to the way how beamer handles verbatim, apparently.

Also, beamer and code can generally can wreck quite some havoc. I have had problems with lots of KnitR where it would stop working for no reason, then the exact same code would work again later, etc. And there are lots of conflicts and bugs you need to know about. So if you run into problems here, don’t blame yourself. It might easily be beamer which is ‘responsible’ for some of the problems.

The lstlisting package

You can just use the lstlisting environment without configuring anything but then again, it will not have code highlighting which is kind of the point in typesetting code (most times at least).

However, I find that without setting your own colours for the listings, it still looks quite boring with the black and white hightlighting (bold vs. non-bold). You can configure it any way you like, can even define yourself which elements are to be hightlighted and how. But it is quite a lot of work if there isn’t something you like out of the box. I personally prefer minted and especially tcblisting – that is minted with tcolorbox (as far as I know, even though it’s called listing). It has these cute little boxes. I like boxes.

Using KnitR

When using knitr to run R in LaTeX, don’t forget to change the file extension from .tex to .Rtex so LaTeX gets a heads up that you want to use KnitR. Otherwise you’ll end up with jumbled code and might spend hours trying to find the mistake, since it isn’t actually in your code. (Just so you know, I speak from experience here 😉 It’s just so easy to forget to do this. Basically happens to me all the time…)

You can use KnitR out of the box on Overleaf. Note, however, that they might not have all the packages you might want. But if, like me, you just want to display code to teach coding, you can eval=FALSE the results (which will be error messages due to lacking packages) and let the students run the code themselves. Since my elaborated fancy didactical plan was not to share the code as a file but rather have them type it themselves from the presentations, to increase the learning effect. Disclaimer: It did not work out the way I had hoped it would 😉

The minted package

If you like fancy, minted probably is for you. It’s kind of like lstlisting but with more beautiful colours and preset options. Give it a try. It’s probably the go-to solution.

Minted and tcblistings

tcblistings use minted and tcolorbox to create highlighted code listings in cute boxes. For me, that’s just too good to be true 😉 Note, however, that Beamer, tcblisting and enumitem are not compatible with each other. There is a bug I haven’t yet found a way around. So you can’t use customized enumerates oder itemize in the same presentation as these code listings! Sad, but true. But maybe there is a not-all-that-inconveniant way for you to keep presentation and code parts in separate sets of slides anyway. Here, it’s on you to get creative 😉

Generally, with the beamer package, there are actually quite a few things which don’t work once you want to use some less common features. So in case you encounter a bug and really can’t see how it’s your fault, web search if it’s a common error or known bug. Maybe there will be a way around it, maybe there won’t.

A workaround for this specific case would be to use beamer with lstlisting.

Wrapup

So, I hope this helped you and provided you with  an overview of possible ways of typesetting code in LaTeX, with a focus on presentations.

Best, the Ninja

Resources

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

How to improve at programming when your current position doesn’t require it & Online Learning Resources

Have you ever felt like you would like to get better at programming, maybe even get a position involving more programming some day but the fact that you currently don’t really need it at your current position seems to hold you back? This post is for you.

Daily practice is key for improvement

You need daily practice if you actually want to improve. You already need daily practice just to keep your skills sharp during a time where you don’t need to use them. Also, if you don’t even have programming skills yet, you probably are too tired after work to sit down and work on a private programming project.

But you should. Programming is a skill which takes a long time to learn. That is, if you want to reach a decent skill level. This means that you have to start regular practice long before you actually need that skill or need to apply for a job, if possible.

The common advice: Find a starting out project to program in your free time

When I first informed myself on this, the most common advice was to find a cool project and try to program it in your free time. But I found that when you don’t have an idea for such a project which makes complete sense to you, you’re not going to go through with it. Without an acutal, urgent need you probably won’t sit down the amount of hours necessary to actually make progress. At least the great majority of people wouldn’t.

Then I tried setting myself mini-challenges. This was a good idea. But there wasn’t a lot of guidance (obviously). This, in return, was discouraging and wasted a lot of time. Of course, time well spent learning something. But since I am really interested in effective learning, I felt that I was wasting time. Effective learning is always better than just playing around. You need curriculum. At least some. That’s when I found out that there are a lot of competitive programming sites which offer useful short exercises where you can do one per day.

Before that, I had tried all sorts of “Learn programing” sites like SoloLearn, freeCodeCamp, the Enki app, just to name a few of my favourites. But really, I didn’t like them all that much. They went through the syntax of the language and that was it. Like learning the vocabulary of a living language but never using it.

Review of some of the materials out there

Here, I want to share links to all sorts of learn coding sites out there. Of course, it’s not extensive but I think it does cover a good few of the most important ones. And maybe has a bit of a different perspective from most other “here are 30 sites to learn coding for free” blog posts out there.

A constraint for me was that the site had to be completely free of charge. So, for example, DataCamp is a no-go. Although, I have still linked to some pay-sites in case you are interested.

But especially as there are so many pages where you can get a similar service for free, I don’t see why I should pay for one of them, when there are so many alternatives available. If it were really brilliant, I would probably pay for it, in theory. Like HackerRank, I like so much at the moment, that I would probably get access for a one-time payment. But most of those apps and sites ask for monthly payment of up to or even starting at 10€ – that is a crazy amount of money and you already get books starting from 10€. I personally would always put more trust in a book in terms of quality and the hope that there might be a logical progression to the teaching; and thus, rather go for that. Also, I just don’t do monthly subscriptions. They eat so much of your money and mostly, when you sum it all up, are not really worth it. 

Also, the amount of sites (plus all the apps!) out there has become so huge, it’s really a full-time job to check them all. That time might be better invested in just picking one and learning to code. These other sites that I found initially focused more on interview prep for experienced programmers or programming contests, but many of them have actually developped training tracks. They also tend to offer a broader range of subjects than many other very popular sites which focus on web development (“coding”) mainly.

Enki app

I had liked the Enki apps daily workouts, but the learning progression was not stable. They give you a random tutorial every day. This was not very effective and I quickly was through with all of their material. Ergo, the workouts started repeating very quickly.  For more, you would now have to pay monthly for access which I am not willing to do since learning-wise, it is not sooo well done. It was really good for a free site (for a while I used it a lot), but not good enough to be paying for it. Sadly, I have experienced this with most of the sites I have tried (and I have tried quite many).

App-wise, you will just get the Enki review here. I tried probably all the most important apps out there. But mostly, in their way of just explaining the syntax of a language, the progress was slow and it was ineffective for me who already knew most of the syntax. You usually can’t skip much or speed up if you’re getting bored. Still you never get any actual programming done which I found both useless and frustrating. Having tried all the apps and “learn the syntax of XY” (disguised as “Learn programming language XY” which is not the same thing, in my opinion), I now found competitive programming sites to be more what I had been looking for. 

Some of them don’t have all the languages you might want, especially the smaller ones and the web dev focused ones.

 

General-purpose learning sites (video-based, MOOCs, etc.)

Many popular sites (Coursera, Udemy, Udacity, Khan Academy, MOOCS like edx, OpenMIT) are video-based and I don’t personally like that. I prefer interactive sites where you can type your code directly. But well, now you have the links to those resources as well.

Online books or blog tutorials

Even though I have a tutorial blog myself, I personally would not try to learn a programming language from a blog. Sometimes you find useful posts for a specific problem you need to solve, that’s mainly what they are good for. I just think that the available interactive things are cooler for actually getting programming experience as a novice programmer.

Youtube tutorials or channels

Some posts on free “learn coding” resources recommend Youtube tutorials or channels. This is, I think, a valid point if there really is an excellent tutorial video out for exactly what you want. So, if what you want isn’t uncommon, there is likely to be one. Sometimes a 5min video can save you an hour of reading a tutorial. But I find that hardly any channels offer sensible curriculum for a motivated learner, so I’m not sure how much you would get out of it in the long run. That’s why I won’t recommend any here.

Sites just/mostly teaching the syntax of languages

 

Many of them are gamified as well

Sites I really like for practice / or of the type I like (challenge-based)

Learn the language tracks are available on for example: HackerRank, HackerEarth (teaches algorithms).

With Hackerrank, for example, I really like their testcases. They don’t just ask you to write a solution on your own (sites like SoloLearn, Codecademy hardly do that in their regular curriculum), they also provide testcases where, for example, overflow is bound to occur. So with every single test you are reminded to remember that. This is a good reinforcment method in  teaching, I think 😉 Also, have I mentioned that supposedly, the only thing which really works wonders in teaching is getting tested? So forget about what learning type you are (visual, audio-visual-bla, etc.) and become a tester. You can skip some of the testcases of course, but the frequent reminder still works wonders. Also, you can learn from other users good (high-ranked) solutions. Especially in algorithms, it’s really worth checking how more experienced programmers did it. However, these competitive programming platforms do kind of encourage bad programming style (and dirty hacks to improve speed), so be sure to take care of that yourselves. Be persistent disciplined when it comes to using good style! And remember to still work on bigger projects every once in a while, since the daily practice from these sites is just one single function without context.

Learn Catch the Flag / Hacking

Also, if you’re interesed, these are some sites where you can learn CTF (catch the flag), something like competitive ethical hacking.

Other / Tutorial-based

More tutorial-based sites which are useful but not for the kind of rapid learning I recommend:

Resources

Also, check these other posts on free coding resources:

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Riding higher waves

At the risk of boring you all with my frequent thoughts on better teaching, I wanted to give you another metaphor on good teaching, inspired by a surfing class I took. To sum it all up, surfing was great fun. But this year, I was a bit unfortunate to get teachers who were a lot worse than the ones I’d had previously. The high waves and the shallow water make for good metaphors for the basics and the advanced topcis I frequently drone on about in my philosophy of teaching well. So, there you go.

The shallows and the high waves

The teachers were over-protective of us in the shallow waters. They helped more than we would have needed help and thereby, didn’t teach us to act independently. I wanted to do so, but it was not encouraged and we weren’t given any instructions on how to catch a wave on our own. They wouldn’t even let us paddle onto the wave ourselves, but rather pushed the board for us. This might seem very nice and thoughtful. At least, that’s how I felt at first.

But then, once we got to the higher waves – waves high enough for me to find them somewhat scary and thus, distract me quite a bit – they hardly helped at all! But since they had been so overprotective with the basics, doing everything for us, I didn’t have a feeling for how to catch a wave on my own. And this doesn’t exactly get any easier when you are panicked by the high waves. The more difficult situation we got thrown into all of a sudden made it difficult to think clearly, let alone grasp a skill on my own which no one had explained to me beforehand. The deep water is not a place to learn the basics. They should have told us those in shallow water. I think this is a very good analogy for teaching since this is exactly what happens in many classes as well. And then the teachers act like you’re an idiot for not being able to figure out the difficult stuff on your own. Because “that’s just what you do and we all had to learn it the hard way”. But really, this means that the teachers are not doing their jobs and there’s no excuse for that. Don’t blame your failings as a teacher on your students! Don’t turn your lack of teaching competence into a ‘character building’ opportunity for your students. This will not make them better people. It makes you a worse person. And a teacher I would fire on the spot if I were in the position to do so.

Don’t excuse your bad teaching as being a ‘character building’ opportunity

This is very apparent in technology classes at technical universities. In the class, you get this ridiculously simple mini example which is so easy that everybody understands it rightaway. Subsequently, teachers go on to over-explain this for 10 minutes. All students, by now, are lured into a false sense of security because the example was easy. Then they set the task for the assigment and it’s 500% more difficult than the example. This, they pretend, is a learning progression. Hint from someone who actually is a qualified teacher and has experience with training with a systematic progression in sports: No, don’t be ridiculous. This is not a progression. A progression challenges you but doesn’t set tasks which are practically impossible to achieve with the basics training provided beforehand. A progressions means setting a challenging, but doable task – not a sink or swim experience. In these programming classes, usually only those survive who had more knowledge beforehand, came from schools where they’d had years of programming practice, or else, they had more advanced friends or relatives who agreed to help them.

This creates the illusion for teachers that the class is actually doable if you’re willing to put in the work. This is a joke. If you pretend to be a teacher whatsoever, your class should be understandable without help from relatives who are experienced programmers! In some of the classes, I even read all the suggested introductory books and 2-3 more but the class was still difficult because you had to look up hundreds of programming libraries and so on. I managed because I worked hard and had some emergency help from more experienced friends. Having to look up stuff is normal in programming, of course. But as a seasoned programmer, you already know what to search for and know where the new information fits into your previous knowledge. A newbie can’t – I repeat – can’t know that. Don’t blame them for your lack of understanding of how learning works!

Maybe it’s a mistake so many people teach at universities who have never gone through teacher’s training. That is not to say that teacher’s training only produces great teachers. We all know that, sadly, it doesn’t. But at least people necessarily have heard about how learning is supposed to work in theory. Having teachers who do not know nor care how learning and teaching is supposed to work should not be allowed. Yet this is the norm at universities. Students are lucky to come across a natural every once in a while. But it is no coincidence self-help gurus stress the importance of mentors: Not to say that you couldn’t learn it on your own. But your results are just going to be a million times better and faster if you happen to come across a good teacher.

Clear instructions for the ‘danger zones’

Danger zones provide excellent opportunities for accelerated learning progress. But especially before being thrown into ‘dangerous situations’ the students are barely qualified to handle at their stage, giving out clear instructions is crucial. With the guidance of a good teacher and very, very clear instructions of what they should or shouldn’t do, treating students to  a difficult challenge will greatly speed up the learning process. If not done well, however, it will be a nightmarish experience which might even end up deterring students from going on with their studies!

Having something like a life line or a safeboat might be enough to circumvent this. Or having more time or trainers to guide students as much as needed. Don’t rush into these situations without carefully planning them. Students need thoughtful teachers who are there to help students when they need it. Maybe even teachers who anticipate pitfalls students are running into because they can’t know themselves due to lack of experience. If you don’t have a lot of means to make this experience as good as possible, use the one most important element: very clear instructions and some abundant background information before you start. It is also important that students understand why certain rules or behaviours are imposed on them or why certain actions might be dangerous. You can always limit the scariness scope of an overly taxing situations by limiting choices and options through clear instructions and rules. Reduce the scope of a problem and you’ll make success much more achieveable.

Another experience from surfing was on this utmost importance of clear instructions, especially with difficult tasks. On a side note, to avoid any confusion: Surfing was a lot of fun overall, not to give a misleading impression, I just wanted to use the opportunity to point out some interesting observations on teaching. Anyway. In the high waves, the teachers hardly took any notice of me at all. As a novice, I had a hard time paddling against the force of the high waves and was constantly being carried away by the current. I was busy remembering where I was and keeping a vague orientation by looking for where the teachers were. Now was the time when I would have needed their help they had so over-abundantly and unnecessarily given to me in the shallows. I didn’t know whether I should just take the next wave I deemed ok (how the hell should I know which wave is ok? But anyway…) or if I should wait for the teacher to make that choice for me, which they had previously done most of the time.

In this difficult situation, however, they made no clear announcement of what I should do and when they took notice of me after I had spent almost 10 minutes paddling against the waves and waiting around for directions from them, both teachers gave me conflicting instructions. They told me to come over to them but my arms were so weak from paddling and the waves had gotten pretty violent, so it wasn’t easy for me to get to them. Then they decided I had drifted off too much and should just carefully get out of the water. I was shocked. Had I just wasted so much of my energy and didn’t even get one wave to ride? The situation had not only drained the physical energy of my arms and the heat out of my body, it had also drained me emotionally since there was no reward for putting in the effort. Afterwards, I sat on the beach resting a little bit and felt that I didn’t really want to get back in at all. I had lost my trust in the teachers. What if they’d let me rot out there in the waves again? I already didn’t have much energy left. Also I didn’t want the emotional blow of having to get back out again without getting one single wave. Maybe I was just tired, cold and stressing about the situation too much. But then again, I think this is exactly how most students feel when taught difficult subjects. They are left alone at sea in conditions nobody prepared them for. 

Just a thought for now 😉

Best,
the Ninja

PS: Oh, and my experience would probably be a starting point of discussion on multiple teachers who are teaching overlapping topics in parallel but contradict themselves. But that’s a topic for another time…

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Didactical Reduction, Part II

In my first post on didactical reduction, I argued that reduction of learning materials to meaningslessness can be detrimental, that teachers should trust in their students’ ability to learn and rise to a challenge. In this post I want to discuss ways of reducing complexity which actually makes sense. The gist is: reduce unneccessary detail, not difficulty. Build complexity in a carefully chosen progression.

Telling the difference between unnecessary detail and challenging complexity

In my post on why programming classes fail and learning ‘algorithmic thinking’, a main example was that students starting out programmig don’t need to know about data types. I will stick with this example here because I just think it illustrates my point so well. The skill to learn I discussed in the post really wasn’t the ‘vocabulary’ of your first programming language, but ‘learning programming’ means successfully communicating with a computer and in order to do that, you need to develop the skill of algorithmic thinking. This skill is independent from your chosen programming language, so you might as well start with a visual lanuage like PocketCode’s Catrobat or Scratch. I would even encourage you to do so.

My favourite illustrative example: data types in introductory programming classes

When took my first programming class, already in the first or second lesson, I was bombarded with data types. I might add now, that since I never write programs that calculate anything, I have never really needed any more datatypes than int, char, string and complex data types to this day. Other primitive datatypes I have ever only used in ‘fake examples’ or ‘program your own calculator’ tutorials. All while you can generally get away with not very much programming in the Digital Humanities, even though I try to program as much as possible, I have never needed any of the other data types to this day. And that first programming class I took was in 2016. So maybe you see what I’m getting at: a new learner really doesn’t need to know about data types. They should maybe informed at some point – once they have mastered string and int – that there are, in fact, other data types which they might need later on and to pay attention. But that should be about enough. Especially since every book on learning a programming language features them anyway. So your students will know where to find out about data types. Once they actually need them.

In that first class, when we were told about datatypes, the only thing it did for me was turn on this destructive internal dialogue: “What? What does it mean? What do I need it for? Should I learn this by heart now? (like how many bytes an int has… the internal representation is different depending on your computer anyway, I must add years later).” And it went on like this. But the most important thought it generated in my mind is this one – I will print it in bold because it’s important: “Wow. Programming must be really difficult. Maybe I’m too stupid to understand it.” This is the common thought students have in this situation because they are fed information which don’t fit into the learning grid in their heads. Unless they have had previous programming experience and already know the content you teach them, it is plain impossible to understand this new information because there isn’t enough context. This means you have utterly failed as a teacher, congrats. So please don’t do that. Only teach things which can find a place in the student’s internal thinking grid. They will not remember information they don’t know where to put. So that’s a complete waste of time.

Children’s books don’t mention data types

I have made the effort of checking many “learn programming” books for this example and it turns out that children’s books never mention data types but books for adults always do. So if in doubt, and if you really have no previous programming experience since children’s books usually start at a low entrance barrier (which can be good but maybe won’t be challenging enough for you), just get a children’s ‘learn programming’ class. They are way more sensible. They introduce concepts only when they’re really needed. If you’re not a complete beginner anymore, some more theory would be better. Remember, I am also a big fan of ‘the bigger picture’ and argue that you should, in fact, learn more background information than strictly necessary (see my post on learning from tutorials vs. books). It is assumed that a didactical approach is essential when teaching children, yet somehow people seem to think adult learning was different.

Imagine explaining everything to a child. Then apply this to adults.

So what I really mean is that you should not reduce difficulty or complexity, but you should reduce unnecessary detail. As a teacher, it is extremely difficult to leave things out, you always want to be as thorough as possible, I know this from experience. But that isn’t good teaching. Good teaching is learning, step by step, to leave out the unnecessary. Learn to simplify. If you don’t know how to explain something in a very simple way because you think the topic to be soo complicated and you just can’timagine how you would explain it to a child or to your grandma and there you go.

Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away. (Antoine de Saint-Exupery)

Systematically planning for effective teaching

It is interesting that we usually give this kind of advice to our students for preparing presentations yet we totally ignore it for our own teaching. Especially, if you teach at the university, you feel like it’s not your problem to simplify things. Students should just suck it up. Well, plot twist. No they shouldn’t. Maybe we should take some time and plan for effective teaching. Because from my experience, I feel that respecting a few simple things will already do the trick.

1.) Leave out unnecessary detail

To “automate” this, especially for classes where there are pratical parts, just plan the practical parts first. Note down only the information needed to complete the practicals. If you end up feeling like important concepts are missing in the end, mention those in the form of a glossary (key term + max. 1 sentence explanation you can put in a visual info block). Unnecessary detail clouds your students’ minds. Unlike you, they lack the experience to tell for themselves which bit of information is important and which one is just a nice-to-have. So they end up with tons of learning material,  large amouts of things to study in a non-brain-friendly format. It will take them ages to write up a summary and find out which parts can be left out and which can’t. For you, making this clear would probably take 5 additional minutes. If anything, always end with a “things to remember” final slide which sums up the concepts you expect them to know by the next lesson. You know how to tell the difference between signal and noise. That’s why they employed you to teach. So rise to your responsibility.

2.) Provide short survival summaries with the most important takeaways

I explain this in the tutorial post on study summaries. Force yourself to sum up all your classes’ contents in no more than one page per lesson and then, at the end, create a survival summary, which sums up the most important concepts from the 12 one-page-per-lesson summaries in one single page. All the detail you need can go into the lesson summaries, the final summary is equivalent to a pass grade in an examination: If the student knows and understands all the concepts on it, even if they know no details whatsoever that should be worth at least a pass grade.

3.) Choose handouts over ‘the slides culture’

Over the last years, I noticed that hardly anybody does handouts anymore. People think that their students have the PowerPoint (or LaTeX!) slides  anyway and can learn from them. But there is an important difference: Slides often contain illustrative examples or unimportant details and mostly, there are way too many slides. Students end up completely lost for which information is important. Provide a one-page handout. This forces you to stick to the key takeaways and leave away unimportant detail. You can still have details in your personal notes and mention them. But please do take the time to hand students a more didactical document than your personal notes. If your notes are sometimes confusing to yourself, the master and producer of that chaos, how do you expect non-experts to understand them?

4.) Mastery comes from mastering the deconstructed minimal building blocks of a skill

I explained this in the post on deliberate practice. For teaching purposes this means: people don’t pay enough attention to the basics! They are often presented in a way which makes students think they already understand everything anyway. This is, probably, the biggest hybris ever. In my experience, hardly anybody – except for real masters of their craft – actually get the basics and understand their vital importance. Don’t teach your students to sweat the small stuff. Rater spend some extra time on the basics. Often, the basics are crammed into the first 10 minutes of a class. This is a big mistake! It’s actually the advanced stuff which is easy, not the other way round. Once you’ve understood the basics. Never assume your students understand the basics, even if they think they do. They lack the experience to judge their own proficiency. The greatest waste of time I have observed in classes is when students don’t have a firm grasp on the basics but don’t dare ask. In the later stages, they are at a complete loss for what to do. It’s your job as a teacher to stress the basics so many times that students really understand them. This will also teach them that it’s ok to ask. If you skip over basics they didn’t understand, you make them afraid to ask for fear of looking like an idiot. There are no studid questions – live this and your students will start asking! Consequently, measure their mastery of the basics with some sort of testing and only move on once they really understood them. Even if it takes 6 out of your 13 lessons. It will be worth it in the end. Give more advanced students a challenging task in the meantime.

5.) Don’t forget the generic “How to approach this type of problem” summary

Even if this is mentioned implicitly in your teaching methodology, don’t assume students can abstract the general methodology from your practical example. That’s how they end up not knowing how to Google scientific literature on their chosen topic. You have to make everything explicit, even if it seems trivial. Especially if it’s trivial because everything which seems trivial to you is likely a vital underlying key concept and exactly the sort of basic knowledge you would be supposed to teach. Even if you think you already did it in your class, please just do provide a little written out step-by-step tutorial so people can go back to that if they don’t remember how to do it. Maybe they forgot to note down one simple step but that missing step will mess up the whole process. I tend to formulate this while explaining to students what they are supposed to do (i.e. explaining the homework, current task, etc.). I always feel like an iditot doing this but this is the moment where you still have feedback for what your students need. You can add additional problems as they come up. Make the list as extensive and detailed as possible. Often teachers have really bad assessment skills when it comes to predicting  what will be a difficult obstacle for a student in a task. Often it is not even the task they can’t manage but, for example, the forgot where to find the data needed for it, etc.

Like I talked about in the “learn programming” post, the “how to approach this problem” part for starting out programming is not the “vocabulary” of a programming language but algorithmic thinking. Where do I start when I am faced with a task like this? That is actually what you should be teaching. It’s called getting people actionable skills. Teach them to teach themselves, the tricks to make things easier, where they can find information, etc. Take the time to write this out even if you feel like your students should already know this because it came up in a prerequisiste class. Don’t play strict here. You’re only hurting your own class if you insist that people should already know this by now. If they don’t (which is likely to be the case), make it your priority to fill the gaps in their knowledge in the most effective way. Make sure they don’t end up in your colleagues class with an even bigger pile of “stuff they would have already be supposed to know”. Don’t cry over spilt milk. Wipe it up before it starts to stink.

6.) Don’t bore the pants off your advanced students

They don’t know everything and still have things to learn, else they probably wouldn’t be in your class. Prepare something to do for advanced students. I mean, honestly, even as an unexperienced teacher, deep down you can tell before you’ve even met your students that their skill level will not be homogenous. So why didn’t you prepare for it in advance? Offering a cool project for advanced students isn’t so difficult. Prepare it once and reuse it forever. Take this one hour it will take to come up with a more complicated problem (you probably already have one in mind anyway) and spell it out in a way that students can work independently. Give them book suggestions or links where they can learn what they need so they don’t need to interrupt your class.

Your class will (and should) move at the pace of the slowest student. If you don’t prepare for imhomogenous classes, more advanced students will be bored drift off quickly. Have advanced mini projects on hand to keep them busy, motivated and interested. Espeically your good students are actually the ones you want to keep happy. They are the ones who might come to the follow-up class. Unless you bore them away. Counterintuitively, advanced students often tend to get ignored by teachers because they are “difficult”. Yes, advanced students are challenging to teach. Give them something task from a real-life project you wanted to delegate to save time anyway. The responsibilty will ensure they know you value their advanced skill, even though you might not have the time for a 1:1 master class right now. Then, think about actually offering 1:1 master classes for motivated students. They will appreciate it because usually, advanced students really love to learn but hardly get the opportunity during classic teaching. If you have the time, challenge and mentor them outside class. They can become great allies and future co-workers in the long term. Also, the more advanced a student, the more they need non-generic help but challenges tailored to their current needs and skill level.

The “mini-project method” also allows you to take extra care of slow students without guilt – you can let everybody else start on the mini-project (which took you one hour to prepare one single time and can be reused indefinitely if it was a good project), so it won’t be at the expense of their learning experience.

Writing this down, I realized I really have a lot of thoughts on this, so expect another follow up at some point 😉

Bye for now,

the LaTeX Ninja

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00

Learn programming from a book vs. tutorial? Thoughts on deliberate practice

In this short little post, I want to share some thoughts on deliberate practice and how it affects coding, learning how to program, etc. I will argue that, in the long run, you can only become a better programmer with some systematic (self-)education, be it from books or academic classes. Tutorials alone, on the other hand, get you actionable quickly but do this at the expense of providing “the bigger picture” which will ultimately harm and slow down your progress.

The concept of deliberate practice

I have been intrigued by the concept of ‘deliberate practice’ for a few years now. It mostly comes up in the context of the so-called 10.000h rule (popularized by Malcolm Gladwell’s The tipping point – which is full of blatantly false information by the way and has been debunked by Steven Pinker, see Resources).

Deliberate practice is needed for expertise and reaching a level of mastery. If you just want the ‘quick fix’, don’t bother using this approach. But maybe consider using it still.  For your own betterment, even if that sounds like an increasingly cheasy idea in our times. Read on to find out why I think you should.

Urging you to go grab a book instead of reading a tutorial probably is weird advice coming from someone owning a tutorial blog. What I  really want to say is that you should choose the medium through which you learn wisely and deliberately. You don’t need to use the same medium all the time but keep track of the ratio of how much you use the quick fix and how seldom you actually take the time to learn and really understand things. For getting things done quickly, a tutorial is great. But in the long run, if you want to become good at some point (and you should have that goal), you need to learn systematically.

 

Adopt good learning habits, relearn the basics and do it well.

Get a teacher, get constant feedback and a systematic learning progression. If you have acquired your skills merely through ‘coding along’ so far, you might want to do some serious catching up by reading a book. Even if it’s an introduction you deem below yourself, seeing as you might already have years of experience under your belt. Go learn your basics. They’re the hardest part but easiest to overlook. Deliberate practice concepts all agree that you need to deconstruct a skill into the absolute basics and master those smallest building blocks. It’s not the ‘big concepts’ which will ultimately make you good. Don’t sweat the small stuff. Go learn your basics. And go for mastery this time.

 

Why don’t you just… read a book for once?

I don’t want to say either that one could learn programming from reading books alone. But what I do say is that a book is, obviously, an overall larger thing than one short standalone tutorial. So it is bound to have some more structure. It has room for some more general explanations than a blog post. In a blog post, lengthy explanations of background information would be distracting as the goal is to get you going as quickly as possible. For your overall learning, however, this is harmful. Getting the easy ‘quick fix’ is not challenging. But without challenge there is no learning process.

Reading books to learn something is not the right approach when you’re in a deadline-driven project and just need results real quick. But even in that situation, I encourage you to take some time for deliberate practise: Read a book on the topic in your free time, in a moment of calm where you’re not pressed for results. This is what the Humboldtian idea of Bildung is: Self-realization, learning something which has no immediate use but will make you grow as a person and in your expertise.

 

The culprits: Lack of didactic guidance, missing big picture

When you learn programming by tutorials and StackOverflow only, there usually isn’t a lot of didactic guidance involved. It seems like the effective way to do things because you get going immediately and only learn what you need to know right now, so you can always keep things relatively simple. But you also don’t get the big picture. You might get actionable advice, but in the long run, this kind of learning alone, while making sure you get started quickly, will also make sure you remain mediocre forever.

 

Training progession and learning

If you learn without a progression, there is not training effect. I spent all my youth on strict training plans for long distance running, so tackling learning this way is all natural to me. But I realized that for a lot of people, it isn’t. They would never even dream of structuring their progress in learning in accordance with well-known training principles. But that is why a (the desired?) training effect is never going to come. If you don’t train, you don’t get better.

And by “training” I don’t mean the fun part of coding along happily, hacking things together so they merely work. Training is the hard work part. It means dedicated, systematic learning with the goal to improve systematically, following a pre-planned progression. You wouldn’t expect to run a marathon without planning out your training like this, why do people expect that it should be any different with other kinds of learning? But they do. And then they sit wondering why they don’t get better.

You won’t get fit if you don’t make a plan and follow thorugh with it. These things don’t happen by chance. With learning, we sometimes are lead to believe that it doesn’t require this continuous dedication like atheletic fitness does. You learn it once and get to keep that skill level forever. That’s why most people get worse once their schooling is done – they just stop learning. Of course, years at the job give you experience. Doing what you’re already good at is fun. But if you want to make any measurable, visible progress, you have to leave that comfort zone and do the work.

Dedicate yourself to getting better or you will stay where you are. Forever. Just ‘showing up’ and doing the work the same way you always did, making the same mistakes you always did, will not make you an expert. There is no way around deliberate practice with a reliable feedback loop. You have to measure your skills before you can improve them. So you see that you really aren’t anywhere near close to where you want to be. This is painful but necessary. You need to acknowledge where you lack skill. Then come up with a plan to expand your knowledge systematically and fill all the gaps. “Just coding along” is not going to do it in the long run.

 

What you do every day… counts more than what you do once in a while

I want to share the one baseline that resonates with me the most: Do it every day. Even if it’s just 5 minutes of habitualized deliberate practice. Get better every single day. Challenge yourself to get better daily. Even if it’s just a ‘mini habit’. What you do once in a while can never beat what you do every day. What you do ‘once in a while’ has a tendency not to happen. If you aim to study for an hour once a week and that doesn’t happen a few times, you will go without practice for weeks. So go for 5 minutes daily. There isn’t anybody who doesn’t have 5 minutes per day. No matter how busy you are. There is no excuse for not taking these five minutes out of your day for conscious improvement. I think it would even be totally justified to do this during your paid work time. 5 minutes more or less can’t hurt your productivity. And the investment will surely pay off.

Late New Year’s resolutions

In the “coding world” classic “book learning” is frowned upon. People favour just getting what you need right now from a quick tutorial or reading up the solution on StackOverflow. I argued, however, that never taking time to do the real, hard work and actually learn it is not a good habit in the long term. So I suggest that you replace it with better ones from now on. It’s not too late for New Year’s resolutions yet 😉 So much for today.

Yours,

the LaTeX Ninja

Resources

Some books touching on ‘deliberate practice’

Cal Newport, So good they can’t ignore you, NY 2012. I found that the book isn’t what the title suggests (it sounds like your common bullshit American self-help manifesto, but it’s really very sound advice). Contrary to the common “passion hypothesis” (live your dream and make your pre-existing passion into your career), he recommends to adopt the “craftsman mindset” which focuses on producing really good output. His Deep Work is great as well. http://calnewport.com/

Josh Kaufman, The First 20 Hours: How to Learn Anything . . . Fast!, London 2014. Was not as good as I had hoped. I really liked the summary on deliberate practice and the idea behind it, but found the book itself a little lacking in depth. After the introduction where he explains deliberate practice (which is the part I loved back when it came out. He really is responsible for my first getting into the idea of deliberate practice), it’s pretty much over. All he does is apply his theory to multiple projects. If you’re not particularly interested in the skills he deconstructs, you really don’t need to buy the book.

Timothy Ferriss, The 4-Hour Chef: The Simple Path to Cooking Like a Pro, Learning Anything, and Living the Good Life, NY 2012. Also with Tim Ferriss’s mimimum effective dose (MED), mainly described in The 4h Chef, the common denominator is that the books mentioned all question the concept of “mastery”. The 10.000h rule stating that you need 10.000h of deliberate practice (that being 4h per work day, 20h per week, 50 weeks per year for ten years) is geard towards “world-class mastery”. Even if you really want to achieve world-class mastery, studies have found that you can get away with way less hours if you practice the right way (deliberate practice as opposed to ‘just showing up’). But Ferriss and Kauffman both bring up a different aspect altogether: They point out that most people don’t actually want that kind of “real mastery”. Kaufman’s great idea behind his book is that mostly, we just want to get started in a skill really, know enough that we can say “I know how to [INSERT SKILL]”. And 20h of real deliberate practice mostly is more than enough for that. Afterwards, we are ready to continue on to real skill acquisition if  still interested. Ferriss is unique in how he stresses the idea of doing the least possible to achieve your goals (the minimum effective dose) which supposedly will save you most of the otherwise wasted time.

And of course: Malcolm Gladwell, The Tipping Point, Boston 2000.

Other

https://jasonhaaheim.com/the-deliberate-practice-book-club/

Steven Pinker: Malcolm Gladwell, Eclectic Detective, in: The NY Times, NOV. 7, 2009.

 

Buy me coffee!

If my content has helped you, donate 3€ to buy me coffee. Thanks a lot, I appreciate it!

€3.00