Pluralsight Software Development Tutorial Series - Training courses related to the software development process

  

·         Hits: 90,713

·         Category: Education » Programming and Web Design

 

(1.95%) Changes:

The Building a Pragmatic Unit Test Suite was added!

The purpose of this process is to ensure, on the one hand, the satisfaction of the needs of users and, on the other hand, ensure the proper quality of the system's operation, and therefore must include validation mechanisms, ie, outputs in accordance with requirements (validation) and reliability, that is, the correctness of the output function (verification). The development process while giving freedom to the analyst must ensure that the timing of the implementation of the project is observed. Software development with commercial software production, optimal use of available parts, as well as management methods, speeding up, and enhancing the quality of software projects.

In the course of training of Pluralsight Software Development Tutorial Series offers various activities involved with the development of software , procedures simplification essential activities such as integration and testing, Utilities and raised in this and other issues in this field are Dance 

Educational titles:
Advanced Unit Testing 
- Introducing Schedule and Schedule Management Techniques - 
End To End Test 
- An Introduction to the Techniques and Advantages of Software Testing (Automated Testing for Fraidy Cats Like Me) 
- How to Work With Brownfield Codebases (Brownfield Application Development) 
- Understanding Building Extensible Applications with MEF 
(Continuous Integration)
- continuous testing by Ncrunch 
- E- house design patterns (Design Patterns Library) 
- using Jenkins for continuous integration (Getting Started With Jenkins Continuous Integration) 
- Inversion of Control (Inversion of Control) 
- the principles of Kanban 
- principles RhinoMocks 
- principles SOLID design Object Oriented 
Testing - First Development Testing 
- Understanding Domain-Driven Design 
- Creating User Storie Uses 
- Collecting the Right Requirements for Developers 
- Creating a Practical Testing Unit 
- And ...

Advanced Unit Testing:
01 DRY versus DAMP 
02 Test Utility Code 
03 Structural Inspection 
04 Identity 
05 Test-Specific Identity

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 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 Run It 
03-Test Doubles Stroke, Fakes and Mocks 
04-Testing Workflows and Goals 

Brownfield Application Development:
1. Introduction 
2. Development Environment 
3. Identifying Pain Points 
4. Isolation 
5. Testing 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. Continuous Testing 
03. Introducing NCrunch 
04. NCrunch in Depth 
05. TDD The Continuous Testing Way The 

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 a Castle Windsor 
7. Using a Structure Map 
8. Using a 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 Stroke 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 Do not Repeat Yourself Principle, Part 1 
08. The Do not Repeat Yourself Principle, Part 2 
09. Principles of Object Oriented Design - The Part One 

Test Part One 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 Eric Evans's advice. 

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 really helpful to your team and customer? Learn the strategies for creating great user stories, as well as tips for avoiding the common pitfalls of many teams fall into. 

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

Gathering Good Requirements for Developers:
In this course you will learn the key skills, techniques and tools used to capture the 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
is a testing center 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 does not prevent 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 will learn about the different styles of unit testing, as well as the use of mocks. Finally, you will wrap up the course by learning about anti-patterns testing and testing unit testing. 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 
- Getting the Most Out Of Your Integration Tests 
- Avoiding Unit Testing Anti-patterns

More info (open / close)

Specifications

Release new release report

Manufacturer: Pluralsight 
Language of instruction: English 
Level of training: Elementary, Secondary, Advanced 
File size: ~ 7500 MB 
Release Date: 18:12 - 1395/8/1 | 2016.10.22 
Source: PC Download / www.p30download.ir 
Rating:   

download links

DownloadCrash ReportGuide

  Training Advanced Unit Testing 
  download - 472.8 MB 
  course Agile Team Practices with Scrum 
  download - 164.6 MB 
  training course Automated Testing End to End 
  download - 499.8 MB 
  training course Automated Testing for Fraidy Cats Like Me 
  download - 427.1 MB 
  course Brownfield Application Development 
  Download - 200.9 MB 
  Building Extensible Applications with MEF 
  Download - 164.7 MB 
  Continuous Integration Course 
  Download - 285.1 MB 
  Continuous Testing with NCrunch 
  Download - 302.5 MB
  Patterns Library Course Design - 1038.4 MB 
  Download - Part One 
  Download - Part II 
  Training Getting Started With Jenkins Continuous Integration 
  download - 416.9 MB 
  course Inversion of Control 
  download - 351.6 MB 
  course Kanban Fundamentals 
  download - 109.3 MB 
  course RhinoMocks Fundamentals 
  Download - 197.2 MB 
  SOLID Principles of Object Oriented Design 
  Download - 791 MB 
  Test First Development - Part 1 
  Download - 200 MB 
   Course Test First Development-Part 2 
  Download- 188 MB 
  Domain-Driven Design Fundamentals 
  Download - 708.7 MB 
  Creating Effective User Stories 
  Download - 221.5 MB 
  Gathering Good Requirements for Developers 
  Download - 512 MB 
  Building a Pragmatic Unit Test Suite 
  Download - 424 MB 
  Download Order - Mail order

File password

www.p30download.com