دانلود Pluralsight Software Development Tutorial Series - دوره های آموزشی فعالیت های مرتبط با فرآیند توسعه نرم افزار

Agile Team Practices with Scrum:
1. About this Course
2. Agile and Why It Works
3. Agile Requirements and Estimation
4. Scrum Fundamentals
5. Agile Planning
6. Enterprise Scrum

Automated Testing End to End:
01-Introduction to Software Testing
02-Unit Testing - Testing in Isolation
03-Integration Testing
04-Functional UI Testing
05-Putting it all Together with a Continuous Integration Server

Automated Testing for Fraidy Cats Like Me:
01-Automated Testing for Fraidy Cats Like Me
02-What's a Test and How to Run It
03-Test Doubles Stubs, Fakes and Mocks
04-Testing Workflows and Goals

Brownfield Application Development:
1. Introduction
2. Development Environment
3. Identifying Pain Points
4. Isolation
5. Tests as Safety Nets
6. Creating Layers
7. Loosening Dependencies
8. Risk and Corruption
9. Releasing
10. Overriding Principles

Building Extensible Applications with MEF:
1. Introduction
2. Attributed Programming Model - Parts
3. Attributed Programming Model - Composition
4. Part Lifetime and Scope
5. Debugging
6. More MEF!

Continuous Integration:
1. A Gentle Introduction
2. Minimum Requirements
3. Building a Solution
4. Build Scripts
5. Integrating External Tools
6. Deployment Automation

Continuous Testing with NCrunch:
01. Test Driven Development Background and History
02. Continous Testing
03. Introducing NCrunch
04. NCrunch in Depth
05. TDD The Continuous Testing Way

Design Patterns Library:
1. Introduction to Design Patterns
2. Adapter Pattern
3. Bridge Pattern
4. The Builder Pattern
5. Chain of Responsibility
6. The Command Pattern
7. Composite Pattern
8. Decorator Design Pattern
9. Event Aggregator
10. Facade Pattern
11. Factory Patterns
12. Flyweight
13. Interpreter Pattern
14. Iterator Pattern
15. Lazy Load Pattern
16. Mediator Pattern
17. Memento
18. Model View Presenter (MVP) Pattern
19. Model View ViewModel (MVVM) Pattern
20. Null Object Pattern
21. Observer Pattern
22. The Prototype Pattern
23. Proxy Pattern
24. Repository
25. Singleton
26. Service Locator Pattern
27. State Pattern
28. Strategy Pattern
29. Template Method
30. Unit of Work
31. Visitor Pattern

Getting Started With Jenkins Continuous Integration:
01. What is Jenkins
02. Installing
03. Creating a Simple Job
04. Plugins
05. The Big Picture

Inversion of Control:
1. Dependency Inversion
2. Inversion of Control
3. Dependency Injection
4. Building an IoC Container
5. Using Unity
6. Using Castle Windsor
7. Using Structure Map
8. Using Ninject

Kanban Fundamentals:
1. Kanban Fundamentals  Basic Concepts
2. Kanban Fundamentals  Personal Kanban
3. Kanban Fundamentals  Team Kanban

RhinoMocks Fundamentals:
1. Rhino Mocks Introduction
2. Using Test Doubles to Improve Unit Tests
3. Hand Rolled Mock Objects
4. Using Mocks to Improve a Unit Test
5. Using Stubs to Control Program Flow
6. Arrange-Act-Assert vs. Record-Replay
7. Rhino Mocks Constraints
8. Custom Constraints
9. StructureMap AutoMocker and Rhino Mocks

SOLID Principles of Object Oriented Design:
01. The Single Responsibility Principle
02. The Open  Closed Principle
03. The Liskov Substitution Principle
04. The Interface Segregation Principle
05. The Dependency Inversion Principle
06. The Dependency Inversion Principle, Part 2
07. The Don't Repeat Yourself Principle, Part 1
08. The Don't Repeat Yourself Principle, Part 2
09. Principles of Object Oriented Design - The Don't Repeat Yourself Principle, Part 3

Test First Development - Part 1:
1. Introduction to Test-First Development
2. Writing Unit Tests Part I
3. Writing Unit Tests II
4. Introduction to Refactoring
5. Driving Design with Unit Tests
6. Isolating Code

Test First Development - Part 2:
1. Test First Development II
2. Acceptance Test Driven Development
3. More Acceptance Test Driven Development
4. Behavior Driven Development
5. More Behavior Driven Development

Domain-Driven Design Fundamentals:
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.

Topics include:
- Introducing DDD
- DDD: Modeling Problems in Software
- Elements of a Domain Model
- Aggregates in Domain-Driven Design
- Repositories
- Domain Events and Anti-corruption Layers
- Reaping the Benefits of Domain-Driven Design

Creating Effective User Stories:
Are you struggling to create user stories that are truly useful to your team and customer? Learn the strategies for creating great User Stories, as well as tips for avoiding the common pitfalls many teams fall into.

Topics include:
- Thinking in Stories   
- Types of Stories   
- Personas   
- Splitting Stories   
- Getting to Done

Gathering Good Requirements for Developers:
In this course you'll learn the key skills, techniques, and tools used to capture requirements.

Topics include:
- Requirements Gathering for Development
- The Big Picture
- A Few Good Requirements
- Requirement Skills and Techniques
- Requirement Activities
- When Requirements Get Together
- Getting Exhaustive
- Scope and Requirements Validation
- Requirements Prioritization
- Issues and Resolutions

Building a Pragmatic Unit Test Suite
Unit testing is everywhere. It is one of the most widely spread engineering practices in the world of software development. It’s important to know how to apply it in a way that helps, and not prevents you from building successful products. This course, Building a Pragmatic Unit Test Suite, is going to show you how to do that. First, you'll learn about what makes a test valuable. Next, you'll learn about the different styles of unit testing, as well as the use of mocks. Finally, you'll wrap up the course by learning about integration testing and unit testing anti-patterns. By the end of this course, you’ll know how to make the most out of your unit and integration tests.

Table of Contents:
- Course Overview
- Introduction
- Understanding Styles of Unit Testing
- Getting the Most out of Your Unit Tests
- Refactoring to More Valuable Unit Tests
- Getting the Most out of Your Integration Tests
- Avoiding Unit Testing Anti-patterns