I’ve published several training courses with Pluralsight that I hope you will find valuable.
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.
— 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.
— 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#.
— 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.