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.
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!
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
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]
https://www.udacity.com/course/design-of-computer-programs--...
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_...
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..
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.
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.
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/
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.
I have no affiliation with it I just love the idea and hope to see more like this.
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.
[0] https://self-service.mirdin.com/products/advanced-software-d...
Basically, in each chapter I give a small detailed introduction to the topic and then students do some exercises to solidify things.
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.
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?
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
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.
- 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.
Closest thing I found recently is this: https://agner.org/optimize/optimizing_cpp.pdf
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.
https://www.amazon.com/Exercises-Programming-Style-Cristina-...
It's now on the second edition which I haven't done.
[0] https://codestool.coding-gnome.com/courses/elixir-for-progra...
1. https://www.techinterviewhandbook.org/algorithms/study-cheat...
For a general programming book I recommend Unit Testing by Vladimir Khorikov https://www.manning.com/books/unit-testing which was recommended by Saša Jurić
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.
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
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.
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.
Learning by doing, with the help of mentors. Excellent way to learn a next language (as you are already familiar with the programming concepts).
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.
Building games and interpreters both feel niche, but i really love working on dramatically different problems than usual. Really helps expand my perspective
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.
"Hands-on Elixir & OTP: Cryptocurrency trading bot"
the latter part of the book is especially good. chapters on performance and notation stand out
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.
I do think, teaching is hard. It basically turned "advanced" into "fundamentals" with correct teaching/learning approach.