So I don't think you should get too hung up on "enterprise architecture" at the moment, partially because you're still very early in your career, but also because enterprise architecture means a lot of things to a lot of different people. At this stage in your career, I really think you should focus mainly on SOLID code, core Object Oriented design concepts, and then understanding patterns. Good architectural strategies are built around all of those concepts, but they're also much much more than that.

For SOLID code, one of my favorite references is actually Dependency Injection in .Net by Mark Seemann. Although he does spend a good amount of time on DI, the recommendations that Mark makes for how to properly structure your code in order to take advantage of DI are very useful in understanding SOLID oriented design principles in general. The examples and code really work through the concepts well, so you get a great explanation followed by some well thought out code.

Clean Code by Uncle Bob is a great reference on how to structure well thought out code that touches on some architectural principles, but doesn't have that as the main focus of the book. Many of the topics in the book you'll find need to be addressed throughout a codebase.

As far as design patterns (which are different then architectural patterns), I don't think you can go wrong with the original Gang of 4 book , although I personally have a C# specific version, C# Design Pattern Essentials. I don't want to put too much emphasis on design patterns, because sometimes they get overused and applied too literally, but they are still very useful. I think the key to design patterns is not just knowing what they are, but determining where they might be applicable to your use case, and whether you should make any small adjustments or tweaks to them.

After you really have a rock solid base of working with code, then you can shift your focus on more architectural concerns. For that, it really depends on what problem your looking to solve, but Domain Driven Design (DDD) is a good way about understanding those problems and to structure the solutions in a well thought out, loosely coupled, and evolvable manner. That "central framework" that you referenced in your post is the business logic, and its the key focus of DDD

Your example isn't dependency injection, it's service locator pattern which is different. Service locator IMO is a piece of crap, you can find a popular post against service locator here.

I built a large game backend at first without using proper DI. It really bit me in the ass because it made our code extremely difficult to test and keep decoupled as the app got larger. Definitely not all IoC containers are on par with each other and some of the IoC crowd goes a bit too far with patterns at times. However, without using DI your code will turn into a mess. You don't really need an IoC container for smaller projects but they should be relatively light weight and a good container is easy to use so I'd always recommend using one.

If you want a good book on the topic, check out Dependency Injection in .NET. Though not PHP specific, it does a great job at explaining how DI works and the core concepts apply to any language.

Systems Analysis and Design in a Changing World (Sixth Edition) <-- this was the version required for a class

Seventh Edition(?)

This book is free from any programming languages and is instead supposed to aide the development of thinking and planning applications.

murach's SQL Server 2012 for developers <-- required for class

murach's SQL Server 2016

Uses SQL to further enforce "forms" for application data structures.

Professional Test Driven Development with C#: Developing Real World Applications with TDD

Book I purchased during my 4000 project class. Team based project where we had to

1. To plan out the application using skills from System Analysis and Design.
   
   
2. Create a presentation to show to a client.
   
   
3. Create a manual to help onboard developers.
   
   
4. Create a manual for clients.
   
   
5. design and deploy a database (database schematic included in onboarding manual).
   
6. Write tests for the application.
   
   
7. Deploy the application to Azure.
   
   After my research at the time, this book seemed to be the most appropriate for my scenario.
   
   

I, personally, do not know of any good online courses for Software Engineering.

I learned most of it through a great textbook:

http://www.amazon.com/Systems-Analysis-Design-Changing-World/dp/1111534152/ref=sr_1_1?ie=UTF8&qid=1420140887&sr=8-1&keywords=software+engineering+changing+world

You really need to have a firm base in understanding your system requirements, your use cases, etc in order to break down problems better.

TDD + Dependency Injection. Mastering those two concepts was critical in my career, and got me over the imposter syndrome in Senior Software Engineer position. I highly recommend the following book, it will completely change how you write modular code: https://www.amazon.com/Dependency-Injection-NET-Mark-Seemann/dp/1935182501

From someone's Amazon review, this is not an exaggeration:

> The Short Story: This is the best software development book I have ever read. By miles. Or, in deference to Mr. Seeman, in kilometers. Stop. Buy this book. It will change how you think, how you reason, how you sleep at night. See you in a year, we will both be smarter.

Right now it is rough around the edges. However, they have a road map for full DSC support. Jeffrey Snover, creator of Powershell and DSC has said chef aligns most with their goals.

So, I'd say it will be the best bet. But, you can get a lot done with a pull server and VM templates.

Checkout this book on Kindle http://www.amazon.com/Windows-PowerShell-Desired-Configuration-Revealed/dp/1484200179

There is a really good book about Dependency Injection in .NET

In regards how to use DI with NHibernate, there is a good article describing just that: Dependency Injection and Unit Of Work using Castle Windsor and NHibernate

I encourage you to read this book

this book really opened my eyes to a lot and it goes at it as if you had no idea about IoC containers and dependency injection. it really Is fantastic.

Disappointing no one else posted this yet but https://www.amazon.co.uk/Dependency-Injection-NET-Mark-Seemann/dp/1935182501 is literally THE book.

Have a browse of Mark's excellent blog too. If you DO use a container (you don't have to, you can manually compose the composition root yourself) you should also NOT use the service locator anti-pattern: http://blog.ploeh.dk/2010/08/30/Dontcallthecontainer;itllcallyou/

Considering that Mark Seemann literally wrote the book on dependency injection in .Net, it's theoretically possible that he does understand all its nuanced complexities, and that dismissing this presentation (which is, naturally, simplified so it makes a good presentation) as "populist nonsense" is a mite hasty.

>ISBN 9781119126355

https://www.amazon.com/Microsoft-Project-Official-Academic-Course-ebook/dp/B071K7N997/ref=tmm_kin_swatch_0?_encoding=UTF8&qid=&sr=

Yup, it is Management Information Systems.

Here is the book

The Satzinger one.