— Frank DeLuca (@frdeluca) June 15, 2016
I’ve created an SVG file with a learning path through many of these courses – open it with IE and the individual nodes are clickable. You can view a PNG image of it (not clickable) as well.
This course offers a quick introduction to ASP.NET Core so that you can be up to speed and productive in short order. It covers installation, app startup, middleware, dependency injection, MVC and Web API, diagnostics, testing, and architecture.
ASP NET Core Quick Start goes beyond the basics into middleware, automated testing and clean DDD architecturehttps://t.co/em6Exoe9ev
— Kevin O’Shaughnessy (@OshaughnessyKev) June 12, 2017
Learn the basics and benefits of effective pair programming, including what not to do. This technique can greatly improve the quality and readability of your code as well as increase knowledge-sharing. You’ll start by learning about the different roles of pairing, when and when not to use paired programming, and several pairing techniques. From there, you’ll go over research that describes the benefits of this practice and learn about a similar technique called mob programming. Finally, you’ll discover how you can set up your workspace for success and how to do pair programming remotely. By the end of this course, you will know the proper techniques and benefits of pair programming, and you’ll be able to use it to your advantage to create better code.
This course teaches the fundamentals of Domain-Driven Design (DDD) through a demonstration of customer interactions and a complex demo application, along with advice from Eric Evans. It’s co-taught with Julie Lerman.
— (((Steven Klassen))) (@mrxinu) June 17, 2016
— Tim Murphy (@timpmurphy) January 15, 2015
— Ben Brandt (@b2ben) November 10, 2014
— Ryan Moseley (@bahamaboy85) September 15, 2014
In this course you will learn when and how to refactor code in order to improve its design and internal quality. You’ll learn about a wide variety of code smells, including how to recognize and correct them when necessary. Finally, the course demonstrates how to apply the principles and techniques covered in a hands-on exercise by completing a refactoring code kata that you can then practice yourself.
— Mark Pearl (@MarkPearlCoZa) October 18, 2016
— Sean Merron (@seanmerron) January 20, 2015
— Julien Fiaffé (@JulienFiaffe) October 27, 2014
This course covers what I feel are fundamental principles of writing object-oriented software applications. Included here are the SOLID principles as well as the Don’t Repeat Yourself principle, with lots of hands-on coding and examples showing the pain points and the refactorings to alleviate them. I highly recommend it if you are building applications using C# or VB.NET (or Java). I also recommend as a companion book that you consider Robert C. Martin’s Agile Principles, Patterns, and Practices in C#.
— Science FTW (@arvind_ICT) July 24, 2017
— Amr Yousef Diab (@GallantGeek) October 28, 2014
This course describes how to build multi-tier applications using C# and a variety of Microsoft development technologies. This first part introduces the concepts related to N-Tier application design, logical and physical separation of concerns, and then demonstrates how to separate application logic in two different ways. In the first example, a data-centric approach is taken to this separation, which was a very common “best practice” approach for many years, especially in the Microsoft development space. In the second example, a domain-centric approach is taken, resulting in a more testable and loosely-coupled application design.
— Sudhakaran Packianat (@lksudha) January 14, 2015
Part 2 of creating N-Tier applications in C# focuses on three topics that I’ve found to be very important in these kinds of applications: testing, persistence, and reuse of core domain logic. This course also expands on some more Domain Driven Design principles and topics, as this style of programming has greatly influenced how I write such applications.
— Craig Cronin (@craigacronin) July 21, 2014
The design patterns library includes over 10 hours of course material from a number of contributors covering many of the patterns described in the classic Gang of Four book Design Patterns as well as Martin Fowler’s Principles of Enterprise Application Architecture. If you’re just getting started, some of these may be a bit advanced for you, but I assure you there are patterns here that will be valuable to developers of all skill levels.
This course describes the principles of web application performance and scalability, and how to measure these capabilities using Visual Studio’s web and load testing tools. I know many developers believe this kind of performance testing is a dark art, and I hope that this 3+ hour course helps to eliminate the fear and encourage more developers to test their applications’ performance, since I know many have the tools already but just don’t know how easy it is to get started using them. For more on this topic, I recommend you look at my friend Paul Glavich’s book on the topic, .NET Performance Testing and Optimization – The Complete Guide.
This is an introductory course on kanban, a fundamental component of Lean. In this course I look at the history of kanban and its use in the real world in both manufacturing and consumer environments, and then provide the basics for getting started with using kanban principles to improve your personal or team effectiveness. I expect to create a follow-up course in the future that will go into more depth on applying kanban to existing teams and integrating it with common agile practices like Scrum.