Ask HN: Programming Courses for Experienced Coders?

There is a general lack of advanced materials in software engineering. This is one area where market economy works against common good, unfortunately. People who have the knowledge and want to capitalise on it are highly incentivised to preparing beginner level materials and maybe a tiny bit to prepare the something for people who already have a bit of knowledge. After that, the number of people who are your potential target drops off sharply and you would have to increase the price dramatically. And it happens that people will not buy a $200 book even if it had $100k worth knowledge in it.

There are some positions available though. For example, I recently found Let over Lambda by Doug Hoyte. Excellent book if you are that kind of programmer.

Another problem with advanced materials is that frequently people are even unable to recognise them as advanced or valuable. It is easy to look at and evaluate things you have experience with, it is much more difficult to impossible to do the same with stuff that is beyond your experience (also called The Blub Paradox: https://www.paulgraham.com/avg.html).

Personally, I just read a lot. I try to keep an open mind and even if I don't agree fully with the contents of the book, I try to use the ideas as inspirations for my own thinking. You can read codebases written by other people and learn new ideas. Over time, you gather a library of solutions to problems and knowledge of when to and when not to apply them.

If you do enough of it, you will find useful knowledge in unusual places.

The problem with a $200 book is that it's hard to tell the difference between a book that contains $100k of knowledge and a book that contains $100 of knowledge.

Hey, here is a thought I realised while buying yet another cookbook. If you buy a cookbook and find ONE recipe that you will like and will be using regularly for the rest of your life, that cookbook was already worth it.

Even if you found zero recipes, that does not mean you wasted time. Maybe if you think in terms of results for that particular cookbook investment, but it is pretty arbitrary way to look at it. What if you tried to measure your return for investment on a single page of a cookbook? For half a dozen coobkooks? For a shelf of cookbooks?

If you continue buying and studying cookbooks, you will find some good recipes in some cookbooks and what you need to look for is the total return on the total of investment. I spent a ton of money on cookbooks but my life is much better for it and I have zero regrets even if many of these cookbooks yielded zero results.

So now back to technical books.

Some of these books will yield new knowledge and some may yield very little or even none at all. You may not know before you buy a book whether it will pay for itself, but you know if the whole business of buying books and learning from them is worth it. I chose to buy and read books even if some of them yield little results because I think I am a better person and a better developer for it. I learned a lot of useful stuff even if I completely ignore majority of everything I read and then forget majority of everything I thought valuable.

This sort of seems to assume that time and money in infinite, though. Buying a recipe book for one recipe seems like a profound waste of resources.

This sort of seems to assume that it is at all possible to gain knowledge and experience without making mistakes.

Hiring people who do not perform seems like a profound waste of resources. Doing projects that fail seems like a profound waste of resources. Learning technology that will not be helpful later in your life seems like a profound waste of resources.

When was the last time you found a cookbook where a significant portion of recipes stayed with you for the rest of your life?

Your comment embodies one of the core tenets of what makes a great programmer. Great programmers are comfortable navigating ambiguity. They make mistakes but quickly correct course. They know how to test ideas in a way that yields signals faster. They know that they need to make mistakes, and know how to keep the cost of those mistakes low.

It’s like being able to walk into a bookstore full of cookbooks, and by skimming a few pages here and there, walk out with 3 fantastic cookbooks.

In other words, good programmers have the ability to quickly understand the full problem space (including business concerns) and efficiently navigate the solution space.

You've just reminded me that o reilly used to publish quite a lot of cookbooks, I think there was a bash one, perl, python etc. That kind of book would probably be quite useful for getting advanced concepts I guess as a lot of more advanced books are quite abstract.

ideally that's what reviews and word of mouth are. But I imagine like other sectors that book publishers are risk averse.

But if anyone is like me and interested in taking a risk on those $80-150 tomes, CRC Press' books have been more hits than misses for me.

Do you have any recommendations ?

CRC has books in pretty much every subject (in and outside of software), so it really comes down to what kinds of topics you are interested in. I can give a dozen recommendation for books in computer graphics, but that may not be helpful for you personally.

But if you are are into graphics programming:

-Peter Shirley's Fundamentals of Computer Graphics is a great comprehensive resource. Despite the name, it serves as a great jumping off point even for experts into a different subdomain if they don't know where to start

- Johnathan Cooper's Game Anim is one of my most recent purachases. A great overview of the animation process, from the views of both the artist and technical engineer. Not just great for concepts but to get an idea of how and where a large studio executes their workkflow in production.

- Most of the GPU series from Wolfgang Engel are worth their weight in gold. The 7 or so GPU Pro series is basically whitepapers on all sorts of (at the time) cutting edge rendering techniques. Then the "GPU Pro 360" books are there if you wanted to focus on a specific subdomain instead of looking across the pro books (e.g. a GPU Pro 360 book focusing on Lighting or Image processing)

No programming book gives me $100k of knowledge. Let’s say the knowledge is 10% of the gain and 90% sweat. I need $1m in lifetime value I couldn’t have got otherwise. If it has that sort of value you build a business around that tech! See OpenAI for an example!

Personally, I just read a lot.

What books would you recommend? I find it hard to learn real world patterns and codebases.

Smaller patterns like inheritance, composition, traits, functional monads, async coroutines, RAII, MVVM, dependency injection, and semaphore synchronization, are easy to learn, but seemingly unhelpful in the grander scheme. Nobody seems to completely adhere to the rules. As a result, these small patterns never seem to lead to clean code.

I loved coding as a child and pursued CompSci in college. But having worked a few years in the industry, I really think I do not know how to solve anything. At one point I felt as if everyone is gaslighting me. But if multiple people from different companies say I need to learn, then I should.

Right now I want to read to know what exactly I am missing in my knowledge about how code works in large codebases

(Edit: Thanks for the reply!)

(...) are easy to learn, but seemingly unhelpful in the grander scheme. Nobody seems to completely adhere to the rules. As a result, these small patterns never seem to lead to clean code.

Good. That is very useful state of mind to be in.

Because these things do not produce cleaner code. They are tools to solve problems.

Coders are like photographers. The ones who like talk the most shoot walls head on and then peep at pixels and mostly discuss hardware. The ones who know how to make good photos do not care about who uses what kind of camera. A camera is just a tool to capture light field.

Clean code is what happens in your mind and as a result of your mental process.

Patterns, composition, inheritance tricks, and so on -- these are things you add to your toolbelt to use it when it is needed. You should continue adding tools to your toolbelt to be able to solve wider variety of problems and have more alternative solutions. But on its own, more tools do not mean mastery and do not lead to clean code.

If anything, more tools without knowledge how to use them leads to less readable code. This happened to me for the first half of my career..

What get you to mastery is by building taste for simple code and ability to self reflect on your work. Taste for simple code means you know why code needs to be simple and you know how clean code looks like.

Self reflection is trying to be objective and judgy about your results. When you write the code, you keep refactoring until you like the results. You write a module, then you polish it until there is nothing else to remove and it does exactly what it is supposed to be doing. You do it long enough and you will have experience to start it closer to a clean result. You may never get to be able to write clean code on the first try but you might get better at having much cleaner first approximation.

Ideally, you also take some responsibility longer term for what you produced. You compare your initial ideas with how they fared over time. You learn some things you thought smart weren't so smart at all. You learn what works and what doesn't work in general.

There is one more way and this is mentoring. I do pair programming with people where we design and implement solutions to progress. Lets me get to know the person better and the person gets to observe the process which can be a huge shortcut in the process of learning to write clean code.

The next step is to realize that there is no clean or unclean code.

I found the book Growing Object-Oriented Software Guided by Tests to be very inspiring. The book demonstrates how to evolve the code architecture, how and when to add new concepts and abstractions, how to listen to the tests, when to refactor etc. The tech in the examples is dated, but the gist of the book is very relevant.

Another classics are: - Working effectively with legacy code - Refactoring: Improving the Design of Existing Code

All of these books have a lot of depth to them

People who have the knowledge and want to capitalise on it are highly incentivised to preparing beginner level materials and maybe a tiny bit to prepare the something for people who already have a bit of knowledge. After that, the number of people who are your potential target drops off sharply and you would have to increase the price dramatically.

I think, even aside from the incentives, its a matter of interest and time. Earlier in my career, when I was learning at a rapid pace, I also had the time and motivation to write blog posts about what I discovered, as did many of my peers. Its also easier to write about beginner concepts, because they're simpler.

As I've advanced in my career, the things I'm learning and doing are more and more complicated, and/or require much more prerequisite knowledge. Not only do I have less time, there's also a corresponding increase in difficulty in writing concisely and coherently about the more advanced concepts.

About once a week I read a blog post in a field I'm familiar with, and recognize it as something I myself would have written 10 years ago. But I also now see in it the potential problems and pitfalls, and tweaks to make to avoid them. I think to myself "I should write a blog post about that", and sometimes even jot down some notes or a draft, but the topic is just so complicated, and the potential problems so subtle, that it takes a large amount of effort just organizing it, and I get bored/distracted and move on, never finishing it.

Talking to those same peers now, they feel much the same. And even with the experts that do manage to write about expert topics, that's become their full time job. Then after a few years of full-time writing instead of full-time doing, I find when they write about a topic that I've been full-time doing while they were writing, there's gaps in their knowledge or new techniques and tradeoffs they've missed.

I don't know how to solve this problem, except maybe figure out a way to give the knowledgeable experts a sabbatical or something, where they can take a break and write. Good luck getting a startup to agree to that, though.

I have a similar feeling. I've got quite a bit of experience and battle scars after 25 years in the field. I've got technical knowledge at different levels: from jr to staff/architect level to CTO.

However, I've never liked writing. First English is not my first language, so I barely managed to write my PhD thesis in that languages, mainly because I had to. But in general I've tried several times to write some extensive piece about something that I am passionate about at the moment, and although in my head the blog post sounds good, once I start writing, I just get lazy and words don't flow.

What has worked for me is mentoring. I am advisor for several startups at different stages. I have weekly 1 hour meetings with their CTOs (sometimes the CEO, depending on the startup). They aske me questions of things they are struggling with, and I give them my POV, ideas and sometimes more questions.

So far that has been very nice. People have appreciated it a lot (I've even been referred as advisor to new founders) and in addition I usually "charge" 0.5-1% equity instead of money, which is a good way to have some stake in projects I like.

That seems to be why the most popular advanced topics are conference talks instead of books. Still takes prep and you lose the quality of a tome, but an hour long talk (possibly with decently annotated slides for later viewings) is probably better worth for the speakers and audiences alike. conference foots the bill with the costs gathered from participants, participants get a variety of talks (so they aren't paying for one tome but maybe a dozen nuggets to serve as jumping off points. Which may be all an advanced participant needs), and the industry gets advertising/potential recruiting from the staff they dispatch.

Of course, I'm sure I don't need to explain the downsides of a talk, Especially one presented by very knowledgable people but not ones who are necessarily expert speakers. But at the same time, that lack of polish may be a light in the darkness that is false platitudes in every other ad.

There is a general lack of advanced materials in software engineering

I wonder how much this is true in other areas (not counting academic papers).

It's not exactly true in law due to the plethora of giant treatises in any specific subject of law, as far as I know that might be a one-off due to US law putting such an (insane?) emphasis on precedent. Basically need a professional lawyer+historian to compile all the relevant stuff.

But other engineering or science disciples? I have no idea one way or the other.

I think it depends on what you mean by advanced and what exactly you're calling engineering.

As you've pointed out in other engineering disciplines, there are researchers who are pretty deeply immersed in the academic papers and help to move the state of the art forward.

In other cases, there are the societies like ASME, IEEE, ASCE, etc. that put out standards or guidelines. These could either be viewed as documents that you use to plug numbers into formulas or you can try to derive the equations from first principles. Often there are training courses or workshops run by these societies, so that's a place to learn. There are trade publications to learn from as well.

Not sure a treatise is exactly a good comparison. That would be more like documentation, where the question here is more “how to get better at programming?”. A treatise isn’t going to tell you how to be a better lawyer.

I’m not sure there’s great content like this for lawyers either even with mandated continuing education requirements. They’re typically a bore and surface level. About the same quality as your average “What’s new in Elixir 1.15” blog post.

And it happens that people will not buy a $200 book even if it had $100k worth knowledge in it.

It is not at all unfashionable to pay $50k for a master's degree, however.

Turning a masters degree into a pay bump is straightforward. But reading books won't get you hired at a new job or even get you a raise at most places.

OMSCS is ~$9k

For me I think it is a little different. There are tons of beginner material and even quiet a few advanced materials, I find the middle (or intermediate) materials lacking. For example, with rendering. Tons of great content with indepth explanations of how to draw a triangle. You can also find lots of good tutorials about advanced procedural generate techniques, but they (correctly) assume a lot of knowledge that is above the simple task of rendering a triangle. There isn't a lot of content to help you get from rendering a triangle to the knowledge you need for some advanced rendering techniques.

I highly disagree. There's a huge amount of material out there for advanced software engineering. The problem is this material is exponentially harder and most programmers aren't interested in this stuff.

What OP is talking about is essentially learning a new language which is sort of trivial and not advanced. It's sort of a parallel track and he likely wants something that doesn't start at the very beginning. Something called: "Learning elixir for experienced programmers". This kind of thing isn't "advanced". It's more like "convenient". Most programmers spend there entire careers in this zone just learning new languages and new technologies. They are sort of moving horizontally through the field rather then upwards.

True advanced stuff is hard af, and the more advanced you get the less and less relevant it is to your job.

Is this a problem in other fields?

And it happens that people will not buy a $200 book even if it had $100k worth knowledge in it.

If this were the case, such a book would be an immediate buy for me. The problem is that you will have to show me that such a book will bring me this value in my culture/country (i.e. not USA) with a very high likelihood - this will be very hard.

people will not buy a $200 book even if it had $100k worth knowledge in it.

I remember paying crazy amounts for books at university and wouldn't have been surprised to have to pay $200 for a book. As it was I bought mine second hand to save on cost.

When people can expense such items then I also imagine a $200 book selling well when properly targeted and marketed.

What sells even better though are courses, and there are many courses out there aimed at corporates which are in the thousands of dollars so again, $200 doesn't seem crazy at all in comparison.

When writing a small application in Go I had great success asking Chat GPT specific questions. It helped me figure out which packages I needed to use and how to interact with them.

I understand that this might not fit your use-case, but it's worth a try. Just be aware that it tends to hallucinate APIs.

If it does hallucinate, you can just paste it the latest documentation and the hallucination rate goes to nearly zero.

Or it apologizes profusely, tells you you’re correct, and fails to fix its reasoning or the examples it gives you.

I told it to stop apologising all the time. It apologised for doing that :)

Did you also try telling it what it should do instead?

No, because there is nothing I wanted it to do instead. Perhaps what I should have done was to change the system prompt to something like "You are a helpful assistant that will admit its mistakes but never apologise for them."

because there is nothing I wanted it to do instead.

"Simply do not say anything and move on" is something to do instead.

probably chatgpt is Canadian :)

I was trying to get it to write some Elixir code to handle Erlang B calculations and it just couldn't figure it out, but it was pretty confident with the wrong things it was printing out.

The rust borrow checker often requires too much critical thinking for ChatGPT, as well.

LLMs confer a tremendous productivity boost. You just have to understand their limits and know when it's faster to think through and write the solution yourself.

A couple of days ago I was trying to make Chatgpt give me the equivalent s3:// string for an https://... s3 bucket. The stupid thing would just replace http with s3, no matter how much I told it what I wanted (I needed to reformat several links, and search engines were just giving me s3 -> http scripts).

It finally landed on me that I was using gpt3.5 . Once I moved to gpt4 it got it right the first time.

Sounds like you need to add some custom instructions to get the tone, accuracy, and concision you want.

I mean you can just run the code and verify its functionality, right? I guess you could be in trouble if you get functioning hallucinations and try to build more around a false foundation.

Does it actually consume the documentation? You could (haven’t tried in a while) also have ChatGPT tell you anything you wanted aslong as you stated “It’s been posted on Wikipedia after your last consumed date”.

I feel like telling it that it’s wrong and linking documentation is the same as referring to Wikipedia?

The person asking the question seems to be looking for a course or textbook with which to challenge themselves.

What you've described is the opposite of that.

I understand. But as a long-time programmer I like to explore new programming languages or APIs by working on a small project. I start with a first prototype to get the feel of the language, before I look into extended documentation. Chat GPT helps with this use-case.

It's also more fun to have something which can be easily extended than to start from scratch.

Just be aware that it tends to hallucinate APIs.

It gives you nice little hints and a different perspective on your api design itself. I'd have a chat with chatgpt and sometimes I'd miss to share specific code and it just assumes or hallucinate on that.

I've taken 2 of David Beazley's courses.[1] And, I highly recommend them. If you haven't seen some of his talks, he's very good at explaining things by building them from nothing.

I took 2 courses: "Rafting Trip" and "Write a Compiler". Both were awesome. The Rafting Trip took us through implementing the Raft consensus algorithm from scratch. And the "Write a Compiler" course had us build a small language using LLVM.

Both courses (but especially the Rafting trip one) were definitely for experienced programmers. In the courses I took, people generally had at least 5 years of professional work. And even still, there were a few people that really struggled to stay on pace in the course.

But at the end, most people had a (kinda) working Raft library or compiler!

[1] https://dabeaz.com/

I have also taken the "Rafting Trip" course and enjoyed it. Second that it is for more experienced developers.

I've also taken David's compiler course, and it was excellent. I highly recommend taking any course he offers that interests you.

Have taken two of his courses (Compiler and SICP) and highly recommend them. The only thing that is stopping me from taking more is I live at the other end of the world and have to stay awake the whole night for 5 days.

I enjoyed the "Rafting Trip" as well, side tracking a bit, anyone have course recommendation for ML ranking and ML recommendation courses or probabilistic data structures and algorithm (for example, bloom filter, Freivalds' algorithm that make multiplying matrix to O(n^2) etc.... etc)?

I came here to mention Dave Beazley's courses and talks.

In particular, I recently prepped/ran a week-long, in-house training session of Dave's Python-Mastery[1] course at my day job. We had a group of 8 with a mix of junior and senior Software Engineers and while the juniors were generally able to follow along, it really benefited the senior SEs most. It covers the whole language in such depth and detail that you really feel like you've explored every nook and cranny by the time you're done.

[1] https://github.com/dabeaz-course/python-mastery/

(I enjoyed teaching the class so much that I've considered offering my services teaching it on a consulting basis to other orgs. If that interests anyone, feel free to reach out to the email in my profile.)

Sold out :(

+1 to this. Back in the day I read his Python cookbook to get into ML and have found only a few other books since then with that quality.

Thank you, looking into it

How was the participation (number of people, interaction between the instructor and participants and interaction among participants)?

I've taken 1 of his course, and I will definitely take more.

As you say, he is very good at explaining things - it's hard to describe, but it just clicks. Highly recommended.

I was a bit worried about the online aspect, but there is a very good flow actually.

The obvious “next step” is experiential, i.e., write complicated programs. Books about writing compilers, databases, operating systems, emulators, file systems, etc. are all useful.

Do you have any book recommendations for those topics?

Crafting interpreters [1] is one such, where the author walks you through writing an interpreter for a toy language. The book uses Kotlin IIRC, but you can write the interpreter in any language of your choice.

1. https://craftinginterpreters.com/

There is a similar crafting an interpreter[1] and compiler[2] pair of books for Go. I've heard good things about it, didn't work through it myself though:

1. https://interpreterbook.com

2. https://compilerbook.com

It uses Java and C. Strictly speaking there's no reason you have to use either language, you can also use the design in the language of your choice (assuming sufficiently matching semantics, like C# or Kotlin instead of Java for Part 1, or a willingness to put in more legwork if you go further afield).

Man, that book was so good! What a tremendous achievement in clarity and insight. I loved it!

I really enjoyed http://www.emulator101.com/. It is a hands on tutorial on how to write an emulator for an Intel 8080 CPU that can run the original Space Invaders. The code examples are in C, but you can find implementations in other languages on GitHub as well.

"Computer Systems: A Programmer's Perspective" is a great introductory systems textbook on everything going on in a computer.

For more advanced C/C++ developers I can recommend "The Linux Programming Interface" - (https://man7.org/tlpi/). It is a GREAT compendium for writing code against the POSIX API. I have a (legal) copy of this book on all the computers I have access to.

"The Database Redbook" - (http://www.redbook.io) is a valuable source on database implementations.

"Compilers: Principles, Techniques, and Tools" (Dragon Book) is a great starting point. The book is out of print and but I think it should still hold up for most basic use-cases.

Building git

https://shop.jcoglan.com/building-git/

Build a blockchain from scratch in go

https://web3coach.gumroad.com/l/build-a-blockchain-from-scra...

Compiling to assembly from scratch

https://keleshev.com/compiling-to-assembly-from-scratch/

If anyone knows of similar books, don't hesitate to comment below.

This is a really good fundamentals resource: https://teachyourselfcs.com/ They list books and videos.

It's not Elixir, but I'm working through Jeremy Koppel's "Advanced Software Design Course". I've been coding for 22 years and it is definitely growing me.

https://www.mirdin.com/

That looks interesting. If you don’t mind me asking. What did you learn there that you couldn’t learn from books or talks?

Same difference between reading a textbook vs taking a lecture. He brings it to life. There's also personal feedback. His content isn't available in any other format I know of.

Do have a look at the testimonials. He hits the nail on the head on many ideas I could intuit but didn't have words for.

I don't know of any books or speakers to compare him to. He's a unique bridge between academia and industry. I suppose you could say his teachings are available in the many academic papers he sources, but those papers are dense. His curation and contextualizion gets the ideas in a form I can comprehend and apply at work.

Is it programming language agnostic?

Yes. The concepts apply to all programming languages. The exercises use multiple programming languages. For example, one exercise has you explore the Git source code (which is in C) to learn how to use a program's data structures to understand an unfamiliar codebase. Other examples have you find bugs in Python code or write Java.

I'd also recommend Mirdin. I did a short interactive course a while back, and I'm considering doing the full interactive course soon.

Highly recommend it as well. I'm a junior developer; that course gave me a much better sense for how to design software and answered a lot of software engineering / design-related questions that had coming up over and over again. I'm also just really allergic to handwave-y fluff, and the Mirdin stuff is just so much more concrete and precise than, e.g., the 'clean code' software engineering advice I've seen on the interwebs.

I took his course as well. It is indeed advanced. I certainly learned a fair amount from it. (coding for 15 years)

I'm still partial to LearnXinYMinutes[0]. It's how I learned enough MatLab/Octave in a couple hours to test out of an intro CS course.

Usually I just use that site in addition to the official tutorial when a concept really stumps me.

Here's their article on Elixir[1]

[0]: https://learnxinyminutes.com

[1]: https://learnxinyminutes.com/docs/elixir/

What an amazing resource. Thank you for this. And even more thanks to whoever put this together.

The project was created and is maintained by Adam Bard, but is open sourced with over 1.7k contributors since 2013

https://github.com/adambard/learnxinyminutes-docs

Haha yeah, I saw that after. In that case, great job everyone!

You consider this to be "for experienced coders"?

Yes. It's not useful for beginners. It's a good way to get a quick introduction to the syntax and idioms of a language you're unfamiliar with.

The Elixir one looks to me like a language reference. Nothing wrong with it, in fact I used to love "language reference" books in the 90s to learn a new language.

It's way better than the typical painful language tutorial that is teaching you about how a variable is like a box containing a value... for every new language you want to learn.

For the sake of other people knowledge, if you appreciate this format to learn a language from a book, search for "language reference" books. They are usually succinct and to the point.

I don’t have any general course recommendations but the strange loop conference videos have been the most inspiring for me. I hope to attend soon, and a life goal of mine is to have something interesting enough to present there.

For Elixir, Dave Thomas’ coding gnome “elixir for programmers” course skips all the menial BS about “what is a string” etc and goes right into the meat and potatoes of leveraging the language correctly. I loved it.

Possibly mistaken but from what I understand 2023 was the last year of Strange Loop - I was hoping to attend 2024’s

I am going to pretend I didn’t see this =‘(

Was there bot enough demand for the content? It seems like the strange loop content was often top notch.

+1 for Dave Thomas's course. Very refreshing and fun.

Strange loop, one of the few conferences where videos from 10 years ago are still relevant today, will be missed.

Retrospective https://www.youtube.com/watch?v=suv76aL0NrA

Hello, recently I've enjoyed Casey Muratori's Performance-Aware Programming course[0]. You could read Algorithms for Modern Hardware[1] to learn similar set of stuff though. Casey's course is aimed at bringing beginners all the way to a nearly-industry-leading understanding of performance issues while the book assumes a bit more knowledge, but I think a lot of people have trouble getting into this stuff using a book if they don't have related experience.

I've also found Hacker's Delight Second Edition[2] to be a useful reference, and I really wish that I would get around to reading What Every Programmer Should Know About Memory[3] in full, because I end up reading a bunch of other things[4] to learn stuff that's surely in there.

[0]: https://www.computerenhance.com/p/welcome-to-the-performance...

[1]: https://en.algorithmica.org/hpc/

[2]: https://github.com/lancetw/ebook-1/blob/80eccb7f59bf102586ba...

[3]: https://people.freebsd.org/~lstewart/articles/cpumemory.pdf

[4]: https://danluu.com/3c-conflict/

Casey Muratori and Jonathan Blow are some of the greatest minds countering the whole programming movement which creates sub par software imo.

While I like some of their opinions they do pontificate an awful lot for folks who haven’t delivered what could be considered “above par” source code- the stuff in their streams is pretty darn messy.

Both of them, especially Casey are focused on extreme performance. If you write graphics engines and low-level tools for games, you have constraints that 99.9% of devs don't.

I was going to say check out something from Casey too. Maybe just randomly jump into one of the 600+ videos for handmade hero and try to see what he's doing. I think Casey is a great educator, even if he has a lot of hot takes.

It's worth pointing out that Handmade Hero is not an example of how anyone should approach making a video game, and even Casey would say that, since that isn't his goal.

Use libraries. Use frameworks. Don't use C++ but reimplement the stdlib because you hate C++ and assume it was designed by morons. Don't spend... how many years has it been now, nearly ten? On a debug room that looks like a high school CS project.

I'm hijacking a bit, but one thing I've been really wanting is some advanced optimization material for C++. There's so much that goes into data locality, branch elimination, faster ways to copy word-aligned data, and so on. I've picked up all I know on the fly, but would love some great resources which go deep into this. Is there something more instructive than Intel manuals?

Closest thing I found recently is this: https://agner.org/optimize/optimizing_cpp.pdf

You might want to check out Fedor Pikus' The Art of Writing Efficient Programs.

Also see Victor Eijkhout's books : https://theartofhpc.com/

Perfect. Thank you!

Also checkout the old (and slim) classic Writing Efficient Programs by Jon Bentley (of Programming Pearls fame).

I really enjoyed “Speed Is Found In The Minds Of People”, a talk by Andrei Alexandrescu.

At first he is just showing simple stuff, but stay with it, he goes deep.

https://m.youtube.com/watch?v=FJJTYQYB1JQ

Ah, I'm familiar with Alexandrescu. Thanks for this suggestion!

My take is that there’s such variance in people’s skill levels and so it’s really hard to cater educational programming content. Personally, I’ve found getting introductory books/courses and skimming through it until you hit something that you don’t understand and then diving deeper into that bit.

It is interesting, though, that you can easily get intermediate training and coaching in basically any sport. But the thing you do for money? Take this very ad-hoc approach.

Concepts and excercises in sport don't change that frequently comparing to programming. Programming is very ad-hoc indeed, it has way more variables for the intermediate level so that the coach won't have enough time to digest the details.

I’m sure you can find individual coaches but the cost will exceed what most people are willing to spend or invest. Take executive coaches for example, they exist but from what I understand they’re largely private coaching and cost $$$.

People age out of being competitive athletes themselves and coaching is a natural way to stay involved with the sport.

Old coders who love coding don't have to do so indirectly.

I'm guessing that anything functional-language-focused aimed at a higher level would work. But I would also like to know the answer to this (and also am focused on Elixir).

Informally I just tend to write tight modules that loosely adhere to hexagonal architecture and are easy to unit-test.

I'm at a startup that is hiring, btw (I would be the one to reach out to). Seeking someone that is... probably like you, actually. Interested in Elixir but trying to aim higher as a self-motivated learner.

How do one get in touch with you? :)

Hi, nice to meet you. I'm an early adopter of Elixir (coming from Haskell/OCaml) and I will second another comment here, I've found the best way for me to learn Elixir is to be frequently building tooling that I either need or want, one habit I started was to migrate small projects I had previously over to Elixir, the community is a pretty good place to go for questions/inspiration. https://elixirforum.com/

Aside from raw theory, the best thing you can do is try to translate a project you have, maybe a toy project of reasonable complexity, and rewrite it idiomatically in the new language. Use all the preferred methods, semantics, and modeling tools of the target language. Use the language's docs and X in Y Minutes page.

But "which methods, semantics, and modeling tools are preferred" is probably what you're trying to learn.

Unfortunately, that's what language docs are for. Like I said, you can get some theory. If you're learning functional programming, you can find books on lambda calculus and category theory and more. But ultimately you have to learn how to build good software, and there are scant few books about that out there. In the functional world, I know of two and they're both in Scheme. So the best approach tends to be feet-first into the fire using the language's docs, and hopefully the creator(s) has documents explaining theory and practice.

https://www.manning.com/books/the-little-elixir-and-otp-guid...

I read this book years ago when i was first learning elixir. I was coding for about 8 years at the time, so not new to the game.

I liked it a lot. I don't think i wrote every project in the book, but it helped me wrap my head around OTP and how erland/elixir projects are structured.

Highly recommend it.

Yay author here, and this made my day <3.

Any chance of a revised version one of these days? I, too, loved this book, but the ecosystem has moved far in the meantime & many of the examples no longer compile.

In this regard, has anyone tried codecrafters.io? Is it worth it?

I've been using it and it's been fun for learning rust. I've only done DNS and web server modules so far, but it has helped a lot in giving me goals that are achievable

(disclaimer: I work at CodeCrafters)

CodeCrafters is a bit light on Elixir support at the moment (only 2/8 challenges support it so far). We're planning on expanding Elixir support soon.

Currently, we're a great fit for Rust / Python / Go - we support a variety of challenges for those, and there's lots of example code from other users to review and learn from.

Well it's not popular (even though it ought to be), but Edsger Dijkstra's A Discipline of Programming is an approachable and informal (by the author's standards) look at solving non-trivial problems in a provably correct way. In fact the entire EWD archive[1] can be arranged into a course pretty readily, although you'll definitely want to skim or skip large chunks of it. Also some of the papers are just acerbic observations on life, which some people like and some don't.

And there's it's big brother Predicate Calculus and Program Semantics by Dijkstra and Scholten that more rigorously formalizes the same approach.

Dafny[2] is one approach out of Microsoft Research that attempts to provide automated tooling around some of those concepts.

All of the above are excellent places to start if you're interested in learning how to write better code with the imperative languages that you're actually going to use professionally.

[1] https://www.cs.utexas.edu/users/EWD/

[2] https://dafny.org/

You can use Coq to teach yourself many of the same ideas from ADP using Penn's Software Foundations (probably the first two books are sufficient).

A somewhat more modern approach of related concepts to ewd's work is the work of Richard Bird which teaches you about using equational reasoning to take a correct naive algorithm and systematically optimize it into a correct and fast algorithm. [0] [1]

Regarding Dafny, there's actually a new book out that should be approachable to anyone with programming experience. [2]

[0] https://www.cs.ox.ac.uk/publications/books/functional/

[1] https://www.cs.ox.ac.uk/publications/books/adwh/

[2] https://mitpress.mit.edu/9780262546232/program-proofs/

One of the real eye openers for me along that journey was realizing that Eclipse refactors were (mostly, except for some rough edges) automated semantic invariant preserving code transformations, which is to say a kind of simplified equational reasoning resting solely on the equivalence.

Equational reasoning is borderline magical, and I look forward to the day when it's as pervasively taught as basic logic.

I have this fantasy in my mind of a language/editor combination that begins with the empty program and only allows legal equational development. Without explicit predication that would just maintain the invariants of the language itself, so no undefined behaviors, but with user supplied predicates would allow a kind of exploratory programming with safety nets. One way to look at it would be explicit symmetry breaking, although I'm not sure that's a good way to describe it to typical working programmers. The idea though is that for a program with the empty specification all code transformations are symmetrical with respect to the spec. And then as the specification is added to certain transformations become symmetry breaking and thus illegal, with said illegality being statically checked. Clearly I'm waving my hands quite a lot here, and I have no clue if it's actually practicable.

Lately, I have been struck by pragmatism of approaches discussed in https://clojuredesign.club/

For example, one can start separating pure functions from side-effects, aiming for aggressively minimal side-effecting functions. Applying this approach to calling REST APIs, one would first create a full request (including the http method, body, headers, etc) in a pure function, and only then send that request to the wire. With such a split, one can easily unit-test the request construction (it's a pure fn), and also explore the request.

It was mind-bending to me when I first heard it. The podcast is full of such approaches and it seems that Chris and Nate, the hosts, have quite some battle scars to source from.

I'm intrigued. Could you provide some pointers on where to start at https://clojuredesign.club?

Peter Norvig's programming course from 10 years ago. It says there "no experience required", but it's intermediate-advanced actually.

https://www.udacity.com/course/design-of-computer-programs--...

It is also very interesting to watch an accomplished computer scientist write code and solve problems.

Specifically for Elixir, I found the first edition of Elixir for Programmers [0] by Dave Thomas to be very good.

It's now on the second edition which I haven't done.

[0] https://codestool.coding-gnome.com/courses/elixir-for-progra...

Thanks! I'll check that out

Edit: Exactly the kind of thing I was looking for

Getting more focused on a particular subtopic seems to be a good way to get somewhat more advanced material. PragProg has a bunch of books for the Elixir ecosystem that might be up your alley (https://pragprog.com/titles/smgaelixir/genetic-algorithms-in..., for example).

I recently went through the Typescript resources over at https://executeprogram.com and found them really effective at solidifying the edges of that particular language for me; wish that was available for more ecosystems.

That book is recommended quite often - I don't agree, I was disappointed. If you know the just the basics of the two topics you won't learn anything new.

There are so many great books on specific domains but it depends on what you want to learn and you can then search for that. "Programming" is obviously too broad a category for experienced people.

Besides most courses being beginner-focussed, there are at least two other related problems:

- Most advanced courses sell themselves dishonestly as beginner-friendly even if they aren't after the first couple of lessons. On the free market everyone is after every single potential customer, no matter what.

- Everything is stretched out so much that information density is annoyingly low. Again free market pays per page and minute and not value.

You might have more luck looking at resources produced free from these constraints and the best place I know is university courses. Still, good ones are hard to come by, but I learned a ton at uni I'd never had learned outside.

Dive into the BEAM VM. https://github.com/happi/theBeamBook

the Architecture of open source applications is a pretty interesting book to see real world examples of design https://aosabook.org/en/index.html

I would not call myself experienced, but I often find myself glancing over documentation first (building a mental model and a map of what features are offered by this thing), then trying to build something, rather than sit through a slow paced course. This may or may not work for you.

The Practice of Programming by Kernighan and Pike. Intermediate-ish level

the latter part of the book is especially good. chapters on performance and notation stand out

I will suggest doing SICP. It teaches good FP patterns, and might complement another FP language well.

SICP. Lectures are on YouTube.

A little known book that many might find interesting is Cristina Lopes's Exercises in Programming Style which takes a single problem and solves it in 40 different ways using Python. [0]

https://www.amazon.com/Exercises-Programming-Style-Cristina-...

I've heard good things about Bradfield CS[0] and CSPrimer[1] (both run by the same person).

[0] https://bradfieldcs.com/

[1] https://csprimer.com/

When I want to take the next step with a new language, I usually find a popular or interesting framework/library for that language, and I do a deep dive into the codebase.

Set it up for local development, then step through calls with a debugger, look at the whole call/request lifecycle, start to tinker with the subsystems..

It's a great way to see the real-world usage of all the core concepts you've been introduced to in the intro/learning courses or tutorials, and be exposed to more advanced patterns.

For Elixir, the obvious choice would be Phoenix if you're on the web app side of things..

Here's a heuristic that works for me, for $foobar, any language and/or sufficiently complicated tech:

Within the documentation, find the sections that deal with the following topics:

  * extending $foobar
  * embedding C in $foobar
  * embedding $foobar in C
  * packaging/distributing $foobar
  * porting/cross-building $foobar

In my experience, these topics are inherently hardest to implement, last to be documented, and trickiest to understand. As such, they make for worthwhile reading for advanced practitioners.

On a similar note, does anyone have any resources for traditional computer vision, SLAM, and computational geometry?

No, there's no such thing as "advanced". It's just that people "forgot" fundamentals of things, then they see those "fundamentals" as advanced.

I do think, teaching is hard. It basically turned "advanced" into "fundamentals" with correct teaching/learning approach.

If you’re looking for advanced courses in Python, I highly recommend a workshop or class from James Powell.

https://www.dontusethiscode.com

Both of Robert Nystrom’s books are awesome and don’t feel beginnery http://stuffwithstuff.com/

Building games and interpreters both feel niche, but i really love working on dramatically different problems than usual. Really helps expand my perspective

Well, I don't know how advanced I am (except in age). But I have found the best advanced training is the same as it was in college. No book makes up for the late night hours. I find other projects and offer to help -- there's always a shortage of coding labor (especially if it's free). You learn what the book or course never discusses -- things like "What the heck was the person trying to do here?" and "Even God doesn't know how this code works!" You know you're in trouble when you see "Oh God! What an evil hack! But it works... don't touch anything!" or "Good luck future Matt! You KNEW this was a horrible job, but did you come back in time and stop me?"

Here's a "life hack" - get a good book that doesn't make any assumptions about your background but otherwise goes deep, and then use an LLM's "talk to pdf" functionality (e.g. via the paid ChatGPT subscription). You can then describe the LLM your particular background and ask it to walk you through the book while skipping through "the boring parts" you are already familiar with.

Mirdin[0] can be helpful too.

[0] https://self-service.mirdin.com/products/advanced-software-d...

David Beazley teaches weeklong intensive courses on Raft and interpreters and SICP. Good use of a corporate education budget.

I have no affiliation with it I just love the idea and hope to see more like this.

https://www.dabeaz.com/courses.html

For Elixir, take a look at Phoenix LiveView course from https://pragmaticstudio.com - they don't start from the beginning, and assume you are already familiar with Phoenix from the guides.

are you talking about learning better ways to organize code / systems to buy into? i mean literally just pick up books on IL and there you go. I dont understand what "experienced" coder means here... you should be able to research on your own @ 10 years+

For Elixir specifically, I liked Dave Thomas’ Elixir for Programmers. https://codestool.coding-gnome.com/courses/elixir-for-progra...

For learning about performance and low level stuff, Casey Muratori’s Performance Aware Programming course has been great. https://computerenhance.com

For higher level software design stuff (beyond just GoF patterns), check out James Koppel’s writing at https://www.pathsensitive.com/ and his courses at https://mirdin.com

I don't know anything about learning Elixir, so, cannot help on that specific topic.

But, here's how I conceptually think about advancing one's understanding in programming.

First, you can aim for breadth or for depth of knowledge. So, learning another language is, in itself a kind of "advance". However, for depth, you'd usually want to pick a specific sub-discipline in programming and concentrate on that. You will have better luck with choosing theoretical disciplines, because those usually are rooted in math, and so have longer history and more systematic approach. The more "practical" aspects usually follow the arc of having an introductory course (at best) with the next learning stage being an "area of active research" (also, the intro course would typically be bad).

To give you an example: in college I became interested in regular languages. So, I was looking to expand my knowledge on the subject. Out of all things that I could dig up on regular languages two seemed most appealing: approximation of context-free grammars with regular languages and equivalence between generating functions and regular languages. In a short while I realized that I don't have enough of mathematical background to go after the generative functions part, but the approximation part turn out to be fun and interesting. I was able to dig up some papers and even try my hand in doing something with the concept.

You'd have similar success if you went after types in programming languages. There are plenty of publications, and you will have multiple steps ahead of you before you run up the wall of "area of active research". My journey down that path started with Benjamin C. Pierce's Types in Programming Languages.

Another direction you may consider is to try to generalize your knowledge. For example, of programming languages. In this regard, I find the book by Shriram Krishamurthy, Programming Languages: Application and Interpretation to be a good introduction to the theoretical side of crafting and evaluation of programming languages.

There are, also, unfortunately, some areas where a lot of programming work has been done, but very little learning material is available, and, especially nothing deep has been produced. For example, if you want to go down the system programming route... there are books, that's true, but the level of generalization leaves a lot to be desired. It's often boggled in all kinds of "practical advise" and very concrete examples based on Linux Kernel code long ago replaced by something else (or worse yet, but original Unix code etc.)

Or, even worse, if you consider fields like testing. Or even GUI. It's surprisingly common and yet surprisingly without much analysis or structure.

This is a pretty great Elixir course that goes into advanced topics: https://kamilskowron.gumroad.com/l/cSGdY

"Hands-on Elixir & OTP: Cryptocurrency trading bot"

The ideas shared in the post replies are great. My approach has been more hands-on and puzzled together recently. I've been digging into harder problems on sites like leetcode to learn more math, and solidify some algorithm and data structure concepts. It has really helped me feel more confident and erase some of the lingering imposter syndrome around the algorithm-side of programming. A great guide that got me started on this was the tech interview handbook[1], which helped me dig into specific concepts instead of just randomly targeting. I've found my ability to review code has also improved through this, as I am picking up different libraries and concepts that I wouldn't have otherwise.

1. https://www.techinterviewhandbook.org/algorithms/study-cheat...

This is something the computer security industry is great at [0][1] that the software industry really needs to catch up on. I would love a weekend to week long course on writing an SMT solver, building a 2D game, training a neural net on custom data, modern C++, peer to peer networking, integrating the lightning network into an app, building a darkweb application, etc. I have not seen many options for that.

Two free resources are Karpathy's neural net zero to hero [2] and Gamozolab's fuzz week [3]. Even just recordings of people who are top in their domain writing code are so useful.

0. https://ringzer0.training/index.html

1. https://www.blackhat.com/tr-24/training/schedule/index.html

2. https://karpathy.ai/zero-to-hero.html

3. https://youtube.com/playlist?list=PLSkhUfcCXvqH2sgJa8_gnB41_...

https://www.destroyallsoftware.com/screencasts are classics and the content and presentation have aged quite well over the years.

The topics demonstrate intermediate/advanced web development/tdd concepts in Ruby but the lessons can easily be applied in other languages. There are even a few videos that show this approach with Python and C.

There are no decent educational resources for experienced programmers (except books for narrow specific technical topics).

I know that from personal experience as an engineer and an educator.

There are strong economical reasons for that:

1. Experienced engineers can only learn something worthwhile from much more experienced ones

2. Extremely experienced engineers are rare kind on its own

3. Being a good teacher is a standalone set of skills and attitudes

4. It is extremely small set of intersection between being good engineer and a good teacher.

5. Courses from such people would cost a fortune to cover time and effort.

6. Experienced developers while being a paying audience, are at the same time extremely picky and hard to educate (because they already feel smart and know how to do things). Which makes situation even worse.

7. At the same time there are millions of noobs ready to consume almost anything you throw at them.

So imagine you are an engineer capable of teaching something. What would you do?

As others have said, expert-level material tend to not lend itself well to a book format.

Instead I find a lot of advance level knowledge is usually shared in tech blog posts and tech talks. The quality of these tends to vary a lot, so you need a bit of curation and due diligence. I myself found the videos from InfoQ very useful with 15 yoe (particularly in the software architecture track).

And if you want the really advanced stuff, you can also read papers. The barrier to entry is higher and sometimes is difficult to connect them to your everyday problems, but it doesn't get more cutting edge that than.

Advent of Code (https://adventofcode.com/)

It's not a programming course per-se, but it's a great resource to master the skill of coding and problem solving.

It's just one part though, it won't teach you anything about architecturing a bigger system.

Yeah, I see this problem. And I found some solution for this issue. We need to promote coaching relationships between starters and experienced engineers.

I was quite impressed with Ardan Labs go tour[1] (free) for learning go.

More of an intermediate resource, but was really good for helping to nail down some golang basics.

Would be interesting to hear from people that have taken their courses.

[1] https://tour.ardanlabs.com/tour/eng/list

More towards the advanced side I'd recommend Fred Hebert's Property-Based Testing with PropEr, Erlang, and Elixir - https://pragprog.com/titles/fhproper/property-based-testing-...

It's also one of the best resources I've come across on property-based testing and is something I recommend to non-Erlang/Elixir programmers as well.

computerenhance.com is a course focused on understanding how to measure and write high performance software. It's a great course targeting experienced programmers.

The more advanced a book or course is, the less popular it can be. What are you looking for in a resource that you don’t get from the docs? Knowing that might help narrow down the recommendations.

If you’re looking to understand what makes Elixir different from the most popular languages and how OTP works, I’d suggest Elixir in Action: https://www.manning.com/books/elixir-in-action-third-edition

If you’re already familiar with that, then take a look at the books from Pragmatic Bookshelf. They have quite a few books that cover different aspects of Elixir development including a recent ML-focused one: https://pragprog.com/categories/elixir-phoenix-and-otp/

What would you be interested in learning about Elixir? I'm writing educational content now.