Lately I've been learning Elixir. Many of the popular resources seem beginner-focused, which feels a bit tedious when you've been coding for over a decade. Are there any popular programming books or courses for more 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 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.
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!
Yes, the knowledge in a book does not automatically bring value. A book in itself is worth as much as the warmth it can give when you throw it in a fire.
But IMO that's a stupid way to view books in general. You would have to contend that ALL books are worth nothing, because you have to expend effort to read it or try to actually make use of the knowledge in it.
So how I define value of a book? From the economics, this would be the opportunity cost which is the next best thing you could do. If you have better use of your time than reading any book then yes, books are worthless to you as long as you can do better things with your time.
For me, I found that reading books brings immense value to me by either directly bringing actionable knowledge or by causing me to think in new ways. Yes, these are my thoughts, but I argue I would not have them if I kept my brain just doing the same thing every day.
I attribute many hundreds of thousands of dollars of my income to ideas in books that I red and some of these books more than others. I am not listing these books here because I also believe that it is not about these books. It is about me getting value from the ideas that I would not know otherwise.
> 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.
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.
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.
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.
> 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.
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.
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
> (...) 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.
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
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.
> 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.
> 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.
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!
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.
(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.)
Most of the content was delivered as a 30min to 1hr lecture and then 3ish hour time to implement what was covered. So that portion was basically heads down, though I guess you could have connected with someone to chat while you were working.
But there were some small group breakouts to discuss the topic and get to know one another. And David would try check in with each person one-on-one every day to answer questions, give tips, and say hi.
So generally, I'd say this is not a high interactivity course like a group project or something. Everyone is working on a separate implementation.
Though, I took the courses online. And, it looks like that's how he's offering them now. But around the time I took the 2 courses, he had just switched to doing that because of COVID. Presumably, the in person courses offered a lot more time to socialize and go out for a drink in the evening.
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.
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.
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.
The point isn't just to make a game, but learn how all how it all works under the hood. He's stated multiple times throughout Handmade Hero that you probably don't want to make a game that way.
> Don't spend... how many years has it been now, nearly ten? On a debug room that looks like a high school CS project.
If you add all the hours up from every episode it's less than a years worth of work...
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.
Its a constraint that every dev should have. Just because you are making a db driven web app doesn't mean your app and db doesn't need to be fast. How on earth can you take the user's bandwith, memory, energy consumption for granted. That's what they are reminding people of.
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.
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.
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..
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.
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.
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.
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.
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.
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.
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.
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."
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?
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.
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.
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.
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.
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]
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.
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 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/
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.
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.
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.
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).
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:
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.
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.
If you're learning Python, and know other programming languages, I have this online ebook [1] that I use with my students so that they learn Python fast enough so that I can teach them about socket programming.
Basically, in each chapter I give a small detailed introduction to the topic and then students do some exercises to solidify things.
I don't have any significant recommendations. With my students I usually build three applications with sockets: a chat server/client, an HTTP webserver and an HTTP webserver serving JSON. Here's an example of an HTTP server using sockets [1], maybe you can follow and understand a little bit more about sockets.
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.
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.
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?
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've been thinking about this, but I don't really know. The podcast is a lot of Clojure, which by itself might be an interesting language to learn. Some people report that learning Clojure was different than other languages, eg Uncle Bob, Gene Kim (see "Love Letter to Clojure") or I think even Paul Graham.
Maybe the Effectively Isolated Serie might be interesting (ep 021-027). Oh, and Cooking Up Composition, about composing functions (ep 093-098).
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.
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.
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?
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.
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]
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.
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.
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.
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
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.
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.
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/
Building games and interpreters both feel niche, but i really love working on dramatically different problems than usual. Really helps expand my perspective
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.
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.
Publishers like Wiley, Addison-Wesley (?), Pearson, Springer Verlag, etc. used to publish some good quality books on advanced topics, at least some years ago. Don't know how it is these days.
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.
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.
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 $$$.
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.
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.
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 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.
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.
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+
computerenhance.com is a course focused on understanding how to measure and write high performance software. It's a great course targeting experienced programmers.
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?"
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.