Maybe a bit too much to start with but I really like https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
by wiremine 2020-10-08
> Immutability is a very useful tool since you have have any kind of dependency -- direct, indirect, implied, etc) -- and there's no worry. But you still need a mechanism to manage mutating data.
I agree. For me it feels like immutable data is a tool, not a universal principle. For example, in low-level C programming or direct control of a register in an embedded context, immutable data isn't a principle, it's just another approach.
What I mean by "universal" is something like SOLID. [1] (Most people only use SOLID for OOP, but Uncle Bob makes it clear in Clean Architecture that he thinks SOLID is universal, and not limited to OOP.)
That said: it does feel like immutable data should be the _default_ approach in many situations. But that's really hard to do in most languages.
System design is probably the most important thing to learn next. Stuff like SOLID principles, dependency injection etc.
This is a book we use a lot at my company: https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/
by that_makes_sense 2019-07-21
I highly recommend this:
Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) https://www.amazon.com/dp/0134494164/ref=cm_sw_r_cp_api_i_weBTCbMNPQ2B1
Also check out Clean Code also by Robert Martin.
by raiflip 2019-07-12
Another few books I've found incredibly helpful:
Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...
Clean Architecture: https://www.amazon.com/Clean-Architecture-Craftsmans-Softwar...
Domain Driven Design: https://www.amazon.com/Domain-Driven-Design-Tackling-Complex...
Clean Code: A Handbook of Agile Software Craftsmanship [0] is a great book on writing and reading code.
Similarly, Clean Architecture: A Craftsman's Guide to Software Structure and Design [1] is, no surprise, a book on organizing and architecting software.
Designing Data-Intensive Applications [2] may be overkill for your situation, but it's a good read to get an idea about how large scale applications function.
The Architecture of Open Source Applications [3] is a fantastic free resource that walks through how many applications are built. As another comment mentioned, reading code and understanding how other programs are built are great ways to build your "how to do things" repertoire.
Finally, I'd also recommend taking some classes. I started as a self-taught developer, but I've since taken classes both in-person and online that have been a tremendous help. There are many available for free online, and if in-person classes work better for you (motivation, support, resources, etc), definitely go that route. They're a fantastic way to grow.
Sounds like something beyond the scope of this site. Also, each of the "areas", that you mentioned, is a huge topic. I would start by reading [Clean Architecture](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164) and [PoEAA](https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420) books before even tying to approach any pf those topics.
https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-a...
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
Maybe a bit too much to start with but I really like https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
I agree. For me it feels like immutable data is a tool, not a universal principle. For example, in low-level C programming or direct control of a register in an embedded context, immutable data isn't a principle, it's just another approach.
What I mean by "universal" is something like SOLID. [1] (Most people only use SOLID for OOP, but Uncle Bob makes it clear in Clean Architecture that he thinks SOLID is universal, and not limited to OOP.)
That said: it does feel like immutable data should be the _default_ approach in many situations. But that's really hard to do in most languages.
[1] https://www.amazon.com/Clean-Architecture-Craftsmans-Softwar...
System design is probably the most important thing to learn next. Stuff like SOLID principles, dependency injection etc. This is a book we use a lot at my company: https://www.amazon.co.uk/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/
I highly recommend this:
Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series) https://www.amazon.com/dp/0134494164/ref=cm_sw_r_cp_api_i_weBTCbMNPQ2B1
Also check out Clean Code also by Robert Martin.
https://www.amazon.com/Domain-Driven-Design-Tackling-Complex...
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...
https://www.amazon.com/Clean-Architecture-Craftsmans-Softwar...
https://www.amazon.com/Patterns-Enterprise-Application-Archi...
https://www.amazon.com/Refactoring-Improving-Existing-Addiso...
https://www.amazon.com/Code-Complete-Practical-Handbook-Cons...
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...
https://www.amazon.com/Mythical-Man-Month-Software-Engineeri...
And just because it’s asked at every interview.
https://www.amazon.com/Design-Patterns-Object-Oriented-Addis...
I’m focused on AWS these days, but a lot of these principals are universal.
https://d1.awsstatic.com/whitepapers/architecture/AWS_Well-A...
Clean Code: A Handbook of Agile Software Craftsmanship [0] is a great book on writing and reading code.
Similarly, Clean Architecture: A Craftsman's Guide to Software Structure and Design [1] is, no surprise, a book on organizing and architecting software.
Designing Data-Intensive Applications [2] may be overkill for your situation, but it's a good read to get an idea about how large scale applications function.
The Architecture of Open Source Applications [3] is a fantastic free resource that walks through how many applications are built. As another comment mentioned, reading code and understanding how other programs are built are great ways to build your "how to do things" repertoire.
Finally, I'd also recommend taking some classes. I started as a self-taught developer, but I've since taken classes both in-person and online that have been a tremendous help. There are many available for free online, and if in-person classes work better for you (motivation, support, resources, etc), definitely go that route. They're a fantastic way to grow.
[0]: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...
[1]: https://www.amazon.com/Clean-Architecture-Craftsmans-Softwar...
[2]: https://www.amazon.com/Designing-Data-Intensive-Applications...
[3]: http://aosabook.org/en/index.html
Clean Architecture (https://www.amazon.com/dp/0134494164) - Uncle Bob has been talking about this for years, but it's a really good exploration of how to build systems.
Turning the Database Inside Out is a talk that really made Apache Kafka and stream processing click with me. https://www.confluent.io/blog/turning-the-database-inside-ou...
Going through and implementing the Raft algorithm was also very formative for me - it's the first time I really started to grok the challenges with building large scale distributed systems. https://raft.github.io/
And to add a paper to the list to not totally go off topic - Birrell's paper "An Introduction to Programming with Threads" I thought was a very useful read - in part for the historical context, but he also breaks down many fundamental concepts that will look very familiar to the modern reader (it was written nearly 30 years ago). It's also very readable. https://birrell.org/andrew/papers/035-Threads.pdf
Anything that touches the real world should be as small as possible.
I've been writing code using tests for about 4+ years and I now can't think of writing code any other way.
I would be scared of refactoring. Also I'm testing the code anyway - why not write it down so it gets done every time?
Run integration tests too for sanity - they're testing the integration of things.
To me: coding without tests is like going caving without a flash light. You don't really know what your code does until you run tests. Your confidence rises when more code is covered.
No it isn't perfect - but not writing tests is not better.
https://www.amazon.com/Clean-Architecture-Craftsmans-Softwar...
I'm sure the book will have many real world code examples, as is fairly typical of his previous works.