Reddit mentions of Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)

Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:

• [Dagger2] (https://github.com/google/dagger)
  
• [RxJava] (https://github.com/ReactiveX/RxJava)
  
• [Retrofit] (https://github.com/square/retrofit)
  
• [Architecture Components] (https://developer.android.com/topic/libraries/architecture/index.html)
  
• Kotlin
  
  With spare time I would also recommend you to read:
  
  
• [Clean Architecture] (https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164)
  
• [Head Frist - Design Patterns] (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_5?s=books&ie=UTF8&qid=1510076882&sr=1-5&keywords=Design+patterns)
  
• [The Pragmatic Programmer] (https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&ie=UTF8&qid=1510076924&sr=1-1&keywords=the+pragmatic+programmer)
  

There are some good C# project examples implementing clean architecture in ASP.NET Core (although the architecture itself could be applied to WPF and other kind of apps).

Have a look at this talk: https://www.youtube.com/watch?v=_lwCVE_XgqI

GitHub repository from the talk here: https://github.com/JasonGT/NorthwindTraders (I'd prefer this one)

​

Another example: https://github.com/ardalis/CleanArchitecture

​

Additionally, if you really want to understand the subject this is an obligatory read: https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

Uncle Bob, 'Clean Architecture' is the book you want. Examples are in Java but you shouldn't have any problems understanding


This book is a must-read, imo.


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_apa_i_FyzqDbV9KJ25Y

Not a magic bullet but these helped me:

• Study the structure of big popular open source projects like lodash or JQuery that have been around for awhile, learn how they structure and organize their code and borrow from it.
  
  
• A book like Clean Architecture might help too.
  
  
• Understand how JavaScript works under the hood and computers in general so you have a better understanding of the whole system, this involves learning low level documentation.
  
  
• Get really good with OOP.
  
  
• Code->Refactor->Code->Refactor, apply and reiterate all the stuff you've learned and see if it works.
  
  Disclaimer: I'm a pretty terrible programmer, but I used to be a lot worse.

Pick up these books:

• Domain Driven Design
  
  
• Patterns of Enterprise Application Architecture - even if you don't do "enterprisey" work it's still a good read with interesting patterns/use cases.
  
  
• Clean Code
  
  
• Clean Architecture
  
  Just remember that the goal of a good architecture is to provide value, but maintain high quality of code that is easy to maintain and change. Separation of concerns , loose coupling, testability, maintainability and scalability are major points to look out for .

If you're in the downtown campus you'll do Python for COMP 1510. The Burnaby campus will be doing Java for COMP 1510.

You should spend time going over HTML, CSS, and Javascript. You'll need Java for certain. You should use w3schools.com to get a good grasp over basic concepts.

One other thing that may help is getting some design books from amazon or as a pdf online to get down coding conventions and ways to think about coding

You'll find that you'll need to test your code in the coding classes and writing code to be testable is a critical skill in school and when you work in the industry.

• Clean Architecture: A Craftsman's Guide to Software Structure and Design by Robert C. Martin

And for Clean Architecture fans, coming August:
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

POSA books by Buschmann are considered to be the textbooky, Knuth/SICP level stuff from when I studied and are architecture equivalent to the GoF's design thing, but as a consequence they're also huge on OOP. The Fowler Book is even more preachy and OOPy but many things are still relevant. The third would be Uncle Bob's Clean Architecture (sorry for cryptic refs, am on mobile, just Google the refs you'll find them.

On the systems design front one should learn ESB and SOA as they are patterns still relevant in this microservices world but most books on the subject are often tied to particular tech (and its often wrong tech like IBM or Oracle or MS proprietary, untraslateable/untransferable stuff). I've heard good things about Thomas Erl books [1].

I've recently read Sam Newman book on Microservices and while it does have a lot of zeitgeist in it at least it's current zeitgeist and the book is decent.

Edits:

• On keyboard now, added links.
  
• [1] Arcitura, Thomas Erl's company has informative (if a bit ugly) websites on both classical SOA patterns and Microservice patterns. Again, it's buzzwordy, preachy, enterprisey CIO-talk but if you cut through it there are some good overviews of various systems design patterns there and are a quick way to ingest the concepts before dedicating your time to these huge tomes.
  
• The mentioned books have aged well in general but some of the ideas they propose haven't aged that well so I'd like to dedicate a few bullet points to those:
  
  • MVC in particular, has lately fallen out of grace as UI pattern and has become delegated to the backend as data-presentation pattern (i.e. how you design, say, JSON API backends wrt DB access and transforming to JSON), whereas front-end UI has migrated to MOVE pattern which, in terms of GoF speek, mostly relates to MVC by replacing MVC's core Observer pattern with a Reactive programming Observable.
    
  • Active Record ORMs (think Hibernate) have fallen from grace and are becoming replaced with SQL building DSLs like Linq or ORMs with SQL builders below them. DTOs have also given way to either Monad-ic data access objects or swung back to the pre-AR/pre-DTO concept of Data Gateways (more common with Linq-style DSLs).
    
  • Reactive design in combination with Message Queuing has become more and more the method of choice for managing distributed state in SOAs.

As far as engineering practices are concerned: Clean Code, Clean Architecture. A secure app/arch is one that is well understood long after you've stopped working on it.

DefCon has a reading list:

https://www.defcon.org/html/links/book-list.html

If you're looking for a starting point, I'd suggest The Tangled Web. Web/browser security tends to be a good high-level starting point.

You asked for books, but I'd highly suggest participating in some CTFs.

I think you're talking about his new book Clean Architecture.

https://www.amazon.de/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

Self-taught software engineer checking in to add on to this.

Everything u/TOM_BRADYS_PET_GOAT said is true.

I'll add a few specific resources:

Computer science fundamentals are really scary and overwhelming if you're self-taught. I'd highly recommend reading The Imposter's Handbook to get started with this topic. You'll want more in-depth material afterwards on each of the various subtopics, but this book is absolutely fantastic as a (surprisingly deep) introduction to all the concepts that's framed specifically to get self-taught programmers up to speed.

After you're familiar with the concepts at a conceptual level, and it's time to just get down to dedicated practice, Cracking the Coding Interview will be an invaluable resource. This book exists for the sole purpose of helping people become better at the types of questions most commonly asked during coding interviews. It's not just a list of a bunch of questions with solutions, it actually explains the theory in-depth, provides drill and smaller practice questions, as well as questions designed to emulate specific interview scenarios at real tech companies like Google, Microsoft, Amazon, etc. It'll even talk about the interview process at those companies outside of just the questions and theory behind them.

As a more general resource that you'll reach for repeatedly throughout your career, I'd recommend The Complete Software Developer's Career Guide. This book covers everything. How to learn, how to interview, how to negotiate salary, how to ask for raises, how to network, how to speak at conferences and prepare talks, how to build your personal brand, how to go into business for yourself if you want, etc. and that's just scratching the surface of what's covered in that book. I did't even buy this book until I was 10 years into my career and it's still very insightful.

And lets not forget, being a good developer isn't just a matter of making things that work, it's a matter of writing code that readable, extensible, and a pleasure for other developers to work on. So to this end, I'd recommend any developer read both Clean Code and Clean Architecture: A Craftsman's Guide to Software Structure and Design

I would strongly recommend reading this book

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

It should be mandatory reading in all CS and SE degrees IMO.

It will not answer your specific question, but it will provide you with the tools and knowledge to understand how best to approach the problem and ensure your architect and design is well though through and draws on the learnings of those who have come before us.

Algorithms? Something like hackerrank.com because there you are supposed to create more complex algorithms from the "simple" ones you learn from books or perhaps in college or from Wikipedia/googling/free online resources.

Design patterns? That book specifically and anything from Robert C. Martin, but preferrably Clean Architecture.

If you are poor there are probably PDFs/epubs somewhere in the web but consider buying the books when they made you rich.

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 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.

Once you've read Clean Code, I'd also recommend Clean Architecture which is in the same series. It's at a higher level that talks about how to organize software projects.

There's a lot of books written about good programming practices, some of which are more advanced than others. Search around on amazon and you'll find a few.

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/ref=sr_1_3?ie=UTF8&qid=1520137256&sr=8-3&keywords=clean+code

I cannot vouch for this specific book, but I read another book in the same series, which taught me a lot of things about software design that I had never even thought about.

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/

Heh, that's a loaded phrase because it people haven't agreed on what it means.

So I agree with both the other posters in that it can include the stack but usually implies a deeper design understanding.

To me, it doesn't make much sense to ask about a rails app's architecture without going into the tech stack precisely because 1) rails apps have the same basic architecture (MVC) 2) the rest of the stack is actually part of the application. Do you use MySQL or Postges or something else? How many rails servers do you have? How many database servers are there and how are they replicated? Etc etc.

However, when you're talking about apps that don't have a given, accepted base design then it's really important to know how it's designed.

I'm going to use the phrase design and architecture interchangeably here, but one could argue they're slightly different.

The architecture of an app influences the "non-functional" characteristics it embodies (also called quality attributes). Furthermore, and more importantly, the architecture itself is (or should be) influenced by the desired non-functional characteristics.

What do I mean by non-functional characteristics? Stuff like:

• Performance
  
• Security
  
• Modifiability
  
• Modular
  
• Testability
  
• etc.
  
  If you think about it, these things are difficult and expensive to change down the road. If you want to add security to an app that's highly modular, you will have a lot of work due to the high amount of decoupling throughout the app. Or imagine trying to add performance to a highly modifiable app. Modifiability usually implies low coupling between parts which also, usually, impacts performance.
  
  So when you think about the architecture of an app, it's how the larger parts are put together to express these non-fuctionals. This can get down to the level of design patterns like MVC (modifiability) and dependency injection (testability) but it starts at a higher level where you look at things like Java packages instead of classes, as an example.
  
  There are a number of books on amazon about this but here are 2 (I've read the first, but not the second):
  
• Software Architecture in Practice
  
• Clean Architecture

Highly endorsed, first book I read out of school:

Code Complete - Steve McConnell


Bonus, engineers at my office were just given this book as recommended reading:

Clean Architecture - Robert C. Martin

Clean Code: Clean Code

Clean Architecture: Clean Arch

​

Just picked these two up myself.. not sure if its what you are looking for, but seem to be very valuable for software design as a whole.

Focus on other aspects. Reading and being able to talk architecture has gotten me a lot further than the “cracking the code”, leetCode type of stuff.

(None of these are affiliate links)

https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420

https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X

This is the third book suggested that was written by Uncle Bob.

Can you maybe explain the Difference between:

Clean Code , Clean Architecture and Clean Coder. All books by Uncle Bob

The Stanford Algorithm book is complete overkill in my opinion do NOT read that book. That's insane. Read it when you've been doing programming for a while and have a grasp of how it even applies.

Here's my list, it's a "wanna be a decent junior" list:

• Computer Science Distilled
  
• Java/ C# / PHP/ JS (pick one)
  
• Do some Programming Challenges
  
• SQL
  
• Maybe build a small web app. Don't worry about structure so much, just build something simple.
  
• Applying UML: and Patterns: An Introduction to Object Oriented Anaysis and Design Iterative Development
  
• Head First Design Patterns
  
• Clean Architecture
  
• Refactoring: Improving the Design of Existing Code
  
• If you're interested in Web
  
• Soft Skills: Power of Habit , A Mind for Numbers , Productivity Project
  
  ​
  
  Reasoning: So, the first book is to give you a sense of all that's out there. It's short and sweet and primes you for what's ahead. It helps you understand most of the basic industry buzz words and whatnot. It answers a lot of unknown unknowns for a newbie.
  
  Next is just a list languages off the top of my head. But you can pick anything, seriously it's not a big deal. I did put Java first because that's the most popular and you'll like find a mountain of resources.
  
  Then after some focused practice, I suggest grabbing some SQL. You don't need to be an expert but you gotta know about DBs to some degree.
  
  Then I put an analysis book that's OOP focused. The nifty thing about that book, is it breaks into design patterns nicely with some very simple design patters to introduce you to design patterns and GRASP.
  
  Then I put in a legit Design Patterns book that explains and explores design patterns and principles associated with many of them.
  
  Now that you know how code is structured, you're ready for a conversation about Architecture. Clean architecture is a simple primer on the topic. Nothing too crazy, just preps you for the idea of architecture and dealing with it.
  
  Finally, refactoring is great for working devs. Often your early work will be focused on working with legacy code. Then knowing how to deal with those problems can be helpful.
  
  FINAL NOTE: Read the soft skills books first.
  
  The reason for reading the soft skills books first is it helps develop a mental framework for learning all the stuff.
  
  Good luck! I get this isn't strictly computer science and it's likely focused more toward Software Development. But I hope it helps. If it doesn't. My apologies.

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

Frameworks like Spring and JPA/Hibernate are used in professional software development, and it is important to know them, but they won't teach you proper ways to architect your software. They are only tools, not substitutes for understanding and judgment.

I would suggest stepping back and learn patterns like Clean Architectures. This will help you understand the principles of software architecture, which is more important than Spring or JPA/Hibernate.

There are plenty of books on this subject. My favorites are Growing Object Oriented Software Guides by Tests, Agile Patterns, Practices and Principles in C# (the book has very little to do with Agile), Clean Code, Clean Architecture, Patterns of Enterprise Application Architecture.

Martin Fowler's website has a lot of good stuff about all architectural topics, from the stuff you're asking about, to microservices and big data.

Uncle Bob has a lot of videos on YouTube that are well worth a watch, like this one. Skip past the first five minutes or so unless you want a physics lesson, too.

Clean Architecture: https://www.amazon.com/dp/0134494164/ (also read Clean Code if you haven't).

Designing Data-Intensive Applications: https://www.amazon.com/dp/1449373321/

OOP is a very general concept and it doesn't go further than the SOLID principles. As for the how this actually gets done is somewhat of an opinion and open to interpretation. I'm a fan of this book....

Clean Architecture A Craftsman's Guide to Software Structure and Design

It has very strong opinions and because of that it gives a consistent message and direction. It should by no means be the only opinion or book you take in to account (learn from as many people as you can). But it's a very good start.

Maybe this? https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164

>How do you all approach designing a solution like this assuming you will not be able to acquire an existing application?

I'll ignore the whole DB selection thing, because this is the real question that you need answered (and will eliminate the need for the DB thing)


My approach would be: focus on solving the clients problem as fast and cheap as possible. Some principles to follow:

1. Forget the whole scaling DB thing. Build the simplest thing that solves the problem the client has NOW.
   
2. Show it to the client. Have the client use it. Get feedback. Don't skip this, it is important.
   
3. Build using architecture and design techniques that will allow you to change the system as you and your client learn more about the problem at hand - you all gonna be surprised by how wrong you were at first.
   
4. Repeat steps 1-3 for as long this app lives.
   
   I basically just described to you - in a super simplified way - the agile/lean way of building software.
   
   >I am willing to put in the time and effort to learn what I need to learn here -- I just need some guidance!
   
   Here are some book recommendations:
   
   Lean Software Development: An Agile Toolkit
   
   Clean Architecture
   
   Continuous Delivery
   
   
   I hope it helps. Feel free to reach out to me if you want to discuss this further.

I find it funny that this guy suggest his audience to read a book that hasn't been published yet.

And then he continues:

> That guy is one of the main guys behind clean architecture.

When the speaker puts in his slides references that he knows nothing about, it says a lot.