Content by Category
.NET 1.x
.NET 2.0
.NET 3.0
.NET 3.5
.NET 4.0
.NET 4.5
.NET Assemblies
.NET Framework
.NET Getting Started
Accessibility
ADO.NET
Advertorials
Agile Development
AJAX
Amazon Web Services
Analysis Services
Android
Architecture
Arduino
ASP .NET Web API
ASP.NET
ASP.NET MVC
ASP.NET WebForms
Azure
B2B (Business Integration)
BDD
Big Data
Bing
BizTalk
Book Excerpts
Build and Deploy
Business Intelligence
C#
C++
ClickOnce
Cloud Computing
Code Contracts
CODE Framework Info - non Technical
CODE on the Road!
COM+
Community
Conferences
Continuous Integration
Crystal Reports
CSLA.NET
CSS
Data
Debugger
Design Patterns
Development Process
Display Technologies
Distributed Computing
Document Database
DotNetNuke
DSL
Dynamic Languages
Dynamic Programming
Editorials
Enterprise Services ("COM+")
Entity Framework
Events
Expression Blend
F#
Fox to Fox
Frameworks
Functional Programming
Git
Graphics
HTML 5
Internet Explorer 8.0
Interviews
IOS
iPhone
Iron Ruby
Java
Java Script
JavaScript
jQuery
JSON
Lightswitch
LINQ
Linux
LUA
Mac OS X
MDX
Messaging
Metro
Microsoft Application Blocks
Microsoft Business Rules Framework
Microsoft Dynamics
Microsoft Expression
Microsoft Office
Mobile Development
Mobile PC
Mono
MsBuild
MVVM
MySQL
Network
NHibernate
node.js
NOSQL
Nuget
Object Oriented Development
Objective C
Odata
OLAP
Open Source
Opinion
Opinions
Oracle
ORM
Other Languages
Parallel Programming
Patterns
PHP
Podcasts
Post Mortem
PowerPoint
Print/Output
Prism
Product News
Product Reviews
Project Management
Prolog
Python
Q&A
Rails
Rake
Razor
Reporting Services
REST
RIA Services
Ruby
Ruby on Rails
Scheme
Search
Security
Services
SharePoint
SignalR
Silverlight
SOA
Social Networks
Software & Law
Software Business
Source Control
Speech-Enabled Applications
SQL Server
SQL Server 2000
SQL Server 2005
SQL Server 2008
SQL Server 2012
SQL Server CE/AnyWhere/Mobile/Compact
SSIS
Subversion
Sync Framework
Tablet PC
TDD
Team System
Techniques
Testing and Quality Control
TFS
Tips
TypeScript
UI Design
UML
User Groups
VB Script
VB.NET
Version Control
VFP and .NET
VFP and SQL Server
Virtual Earth
Vista
Visual Basic
Visual Basic 6 (and older)
Visual FoxPro
Visual Studio .NET
Visual Studio 11
Visual Studio 2005
Visual Studio 2008
Visual Studio 2010
Visual Studio 2011
Visual Studio 2012
Visual Studio Tools for Office
VSX
WCF
Web Development (general)
Web Services
WebMatrix
WF
Whitepapers
Windows 7
Windows 8
Windows Azure
Windows Live
Windows Phone 7
Windows Phone SDK
Windows Server
Windows Vista
WinForms
WinRT
Workflow
WPF
XAML
Xiine Documentation
XML
XNA
XSLT



LearnNow


XAMALOT
 


LearnNow

Category: Testing and Quality Control


35 Articles
found and displayed in this view.

  • Reengineering .NET: Injecting Quality, Testability, and Architecture into Existing Systems - Chapter 3: Unit Testing

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Monday, November 19, 2012
    Quick ID: 1211073
    This excerpt is from Reengineering .NET: Injecting Quality, Testability, and Architecture into Existing Systems, by Bradley Irby, Published Oct 24, 2012 by Addison-Wesley Professional. Part of the Microsoft Windows Development Series series. Copyright 2013, ISBN-10: 0-321-82145-9. To Purchase this book go to: http://www.informit.com/store/reengineering-.net-injecting-quality-testability-and-9780321821454 .

  • Building Windows 8 Apps with C# and XAML - Introduction to UI Design Patterns for Windows 8 Apps Chapter Excerpt

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Sunday, November 11, 2012
    Quick ID: 1211053
    In this excerpt from Building Windows 8 Apps with C# and XAML, learn about the various parts of MVVM and how to apply it with a special focus on testing. By Jeremy Likness, Published Oct 25, 2012 by Addison-Wesley Professional. Part of theMicrosoft Windows Development Series series. Copyright 2013 ISBN-10: 0-321-82216-1 ISBN-13: 978-0-321-82216-1. To Purchase go to: http://www.informit.com/store/building-windows-8-apps-with-c-sharp-and-xaml-9780321822161?w_ptgrevartcl=%20Introduction%20to%20UI%20Design%20Patterns%20for%20Windows%208%20Apps%20_1960915.

  • Behavior-Driven Development Using SpecFlow

    Magazine/Issue: CoDe Magazine, 2012 Jul/Aug
    Release Date: Wednesday, June 27, 2012
    Quick ID: 1208081
    As software development becomes complicated, writing unit tests provides a protection against constant changes and modifications. Traditionally, unit tests were written by testing each piece of the application layer in isolation. With the advent of behavior-driven development, now our unit tests can be composed into user defined stories. Each story represents a single feature of the application which can be tested from end to end. This method makes sure that the unit test only passes when the story is completely done. In this article I’ll show you how to use SpecFlow and WatiN to write BDD-style tests to implement user stories.

  • Debugging Hard to Reproduce Issues

    Magazine/Issue: CoDe Magazine, 2012 Jul/Aug
    Release Date: Wednesday, June 27, 2012
    Quick ID: 1208091
    Software developers live and breathe debugging. It’s an essential and integral part of our day-to-day job. Whenever we are confronted with any bug in code, our typical first question is, “How can I reproduce this issue?” Any problems that cannot be reproduced are generally considered tricky to resolve. In order to really understand the challenges with debugging hard to reproduce issues, let’s walk through a few scenarios here.

  • Windows Phone 7 Development Using MVVM and Unit Testing

    Magazine/Issue: CoDe Magazine, 2012 Jan/Feb
    Release Date: Wednesday, December 21, 2011
    Quick ID: 1201081
    As readers of this magazine, you are all experts at certain facets of software development, be it for the desktop, the web, SQL Server and now mobile platforms. Mobile programming was a fairly arcane development arena up until the recent announcement of Windows Phone 7 (WP7). Prior to WP7, you had to become intimately familiar with the myriad platforms and form factors available and write your programs to each of those phones. With the advent of WP7, Microsoft is now controlling the hardware capabilities of the phone making it much easier to develop for these platforms. You can now also leverage existing skills in Silverlight and XNA to write your apps. But the question always remains: how do I get started and what is the best way to write for the new WP7? In a previous article, CODE Magazine Jan/Feb 2011, I showed you what to do to get started; now I want to show you the best way to apply what you have learned in that article. I will use Silverlight, the Model-View-ViewModel (MVVM) pattern, and Silverlight Unit testing to build a sample app.

  • Post Mortem: Developing the OSS Project AutoMapper

    Magazine/Issue: CoDe Magazine, 2011 May/Jun
    Release Date: Thursday, March 31, 2011
    Quick ID: 1105041
    Jimmy explores what went right and what went wrong with version 1.0 of AutoMapper.

  • Chapter 3 - Planning Your Testing

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Sunday, March 20, 2011
    Quick ID: 1103013


  • Anti-Patterns: TED (Test-Eventually Development)

    Magazine/Issue: CoDe Magazine, 2011 Jan/Feb
    Release Date: Tuesday, December 28, 2010
    Quick ID: 112081
    Software developers are good at writing applications. Testers are good at testing applications. In the software development world where separation of concerns is a never-ending quest, it seems logical to apply the rule to the software development cycle. “Let the developers code; QA can be responsible for making sure it works.” It provides an object-oriented management approach where each team is responsible only for what they are best at, and the two teams interface through one simple property, each: the result of their logic and expertise. The system is of logical design. It appears to be a logical pattern. Or so it seems.

  • Unit Testing CLR Assemblies Using IronRuby

    Magazine/Issue: CoDe Magazine, 2010 Nov/Dec
    Release Date: Friday, October 22, 2010
    Quick ID: 1011101
    For a very long time, .NET developers have envied the simplicity and the beauty of the Ruby language. The dynamic behavior, duck typing and compact code are some of the main features of the Ruby language. Now, .NET developers can enjoy the same benefits using the IronRuby framework. This article explores the possibilities of using IronRuby in the CLR world. The main focus will revolve around the sphere of unit testing CLR assemblies using the IronRuby framework.

  • Building .NET Systems with Ruby, Rake and Albacore

    Magazine/Issue: CoDe Magazine, 2010 May/Jun
    Release Date: Friday, May 07, 2010
    Quick ID: 1006101
    Automated build tools have been around for a long time.Many of the early tools were simple batch scripts that made calls out to other command-line tools like compilers and linkers. As the need for more and more complexity in the build scripts was realized, specialized tools like Make were introduced. These tools offered more than just sequential processing of commands. They provided some logic and decision making as well as coordination of the various parts of the build process. Since Make was first introduced, many variations and specialized versions have been introduced for various languages and platforms. Rake - the “Ruby Make” system - may not have much more than its namesake to claim a connection to Make, but it is a build tool that is quickly growing in popularity and providing .NET developers with new options.

  • Advanced .NET Debugging

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Sunday, February 14, 2010
    Quick ID: 100053
    Mario Hewardt takes a look at the internals of the CLR heap manager and the GC and some common pitfalls that can wreak havoc in your application.He shows how to utilize the debuggers and a set of other tools to illustrate how to get to the bottom of the problems.

  • Ensuring Quality Code

    Magazine/Issue: CoDe Magazine, 2010 Mar/Apr
    Release Date: Friday, February 12, 2010
    Quick ID: 1003021
    Every developer needs to test their code, or have it tested by someone.I don’t know about you, but I am horrible at testing my own code. Does this mean that I do not need to test my code? Heck, no! It is always best if you do not rely on your end user to test your code. This can end up with a very frustrated user, and your user can lose faith in your ability to get their project done.

  • S.O.L.I.D. Software Development, One Step at a Time

    Magazine/Issue: CoDe Magazine, 2010 Jan/Feb
    Release Date: Friday, December 11, 2009
    Quick ID: 1001061
    Derick outlines how to achieve the benefits of low coupling, high cohesion, and strong encapsulation. He also shows how the five S.O.L.I.D. design principles can get you there.Most professional software developers understand the academic definitions of coupling, cohesion, and encapsulation.However, many developers do not understand how to achieve the benefits of low coupling, high cohesion and strong encapsulation, as outlined in this article. Fortunately, others have created stepping stones that lead to these goals, resulting in software that is easier to read, easier to understand and easier to change. In this article series, I will define three of the primary object-oriented principles and show how to reach them through the five S.O.L.I.D. design principles.

  • Introducing Advanced Code Contracts with the Entity Framework and Pex

    Magazine/Issue: CoDe Magazine, 2010 Jan/Feb
    Release Date: Friday, December 11, 2009
    Quick ID: 1001101
    Martin introduces Design by Contract and Code Contracts, and gives you a sneak preview of Pex—Microsoft’s new test-suite generator. Along the way, he will show you how to add contracts to ADO.NET entities and some interesting coding strategies, good practices, and pitfalls you may encounter while making a deal with your code.With Code Contracts, Microsoft delivers its own flavor of Design by Contract for the .NET Framework. But wait, what is this thing sometimes called Contract-First Development? How will it change the way you develop software and write your unit tests? And first and foremost, how do you use Code Contracts efficiently?In this article, I will introduce Design by Contract and Code Contracts, as well as give you a sneak preview of Pex-Microsoft’s new test-suite generator. Along the way, I will show you how to add contracts to ADO.NET entities and some interesting coding strategies, good practices, and pitfalls you may encounter while making a deal with your code.

  • CHAPTER 2 The Case for Manual Testing

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Sunday, October 04, 2009
    Quick ID: 090133
    The origin of software bugs begins with the very origin of software development itself. It’s clearly not the case that we started out with perfect software and invented ways to screw it up.(1) Indeed, the term bug has been in common use within software development from the inception of the discipline(2) and is a nomenclature that is used today in every office, garage, dorm room, data center, laboratory, bedroom, cafe, and every other place where software is developed. The first software had bugs, the latest software has bugs, and so have all the bits and bytes in between. Software is not, and likely never will be, bug free.

  • Why Automated Software Testing Fails and Pitfalls to Avoid

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Saturday, May 16, 2009
    Quick ID: 090053
    “This excerpt is a sample chapter from the book, Implementing Automated Software Testing: How to Save Time and Lower Costs While Raising Quality, authored by Elfriede Dustin, Thom Garrett, and Bernie Gauf, published by Addison-Wesley Professional, March 2009, ISBN 0321580516, Copyright 2009 Pearson Education, Inc. For more info, please visit http://www.informit.com/store/product.aspx?isbn=0321580516 and Safari Books Online subscribers can access the book here: http://my.safaribooksonline.com/9780321619600

  • Hudson Continuous Integration Server

    Magazine/Issue: CoDe Magazine, 2009 May/Jun
    Release Date: Monday, April 27, 2009
    Quick ID: 0906071
    Hudson makes continuous integration easy and powerful.Though Hudson is a Java project, it can easily build your .NET applications. You configure Hudson easily via the web interface rather than tweaking XML. With plenty of plugins available to .NET projects, Hudson provides plenty of powerful features.

  • Isolating Dependencies in Tests Using Mocks and Stubs

    Magazine/Issue: CoDe Magazine, 2009 May/Jun
    Release Date: Friday, April 24, 2009
    Quick ID: 0906061
    Unit tests are not “unit” tests if they test things other than the System Under Test (SUT).In order to test a SUT (the class to be tested), a developer must make sure that the class’s dependencies won’t interfere with its unit tests. Enter mocks and stubs.

  • Speed Up Project Delivery with Repeatability

    Magazine/Issue: CoDe Magazine, 2008 Nov/Dec
    Release Date: Friday, October 24, 2008
    Quick ID: 0811051
    Automate high-friction, unpredictable tasks in your environment to regain sanity and achieve a rapid, sustainable pace.Every environment has them: The dreaded manual tasks that drain productivity from the team and adds instability to the processes. We usually only dedicate half our brain power and never enough time to deal with them, which only compounds the problem. What if you could easily automate out the most painful tasks and gain a huge boost in productivity and speed of delivery?

  • Introduction to Scrum

    Magazine/Issue: CoDe Magazine, 2008 May/Jun
    Release Date: Friday, April 18, 2008
    Quick ID: 0805051
    Scrum is an agile software development process to manage software projects. Scrum is based on three simple principles: visible progress, constant inspection, and adaptation. With Scrum, teams use an empirical approach to adapt to changing requirements and priorities. Teams using Scrum focus on delivering working software to their customers on a frequent basis.

  • Behavior-Driven Development

    Magazine/Issue: CoDe Magazine, 2008 May/Jun
    Release Date: Friday, April 18, 2008
    Quick ID: 0805061
    Extreme Programming and Scrum compliment each other, but they weren’t made from the start to fit together hand in glove.Practicing Extreme Programming and Scrum are more effective when practiced together, and even more effective when practiced together as Behavior-Driven Development.

  • Heard on .NET Rocks! Andy Leonard on Unit Testing Your Database

    Magazine/Issue: CoDe Magazine, 2008 May/Jun
    Release Date: Friday, April 18, 2008
    Quick ID: 0805111
    May/June 2008 .NET Rocks! column

  • Ask the Doc Detective

    Magazine/Issue: CoDe Magazine, 2007 Nov/Dec
    Release Date: Friday, October 26, 2007
    Quick ID: 0711091
    Nov/Dec 2007 Doc Detective Column

  • Layered Architecture, Dependency Injection, and Dependency Inversion

    Magazine/Issue: CoDe Magazine, 2007 - May/Jun
    Release Date: Thursday, April 26, 2007
    Quick ID: 0705071
    Building loosely coupled application architectures requires more than just separating your application into different layers.In this article, I’ll take a project that was built using techniques that result in fragile, hard-to-test code and introduce some principles, techniques, and refactorings that will help you realize flexibility and testability in your applications.

  • Purporting the Potence of Process

    Magazine/Issue: CoDe Magazine, 2007 - Mar/Apr
    Release Date: Friday, March 02, 2007
    Quick ID: 0703021
    Do you ever feel like you’re beating your head against a wall? I know I do; quite often, in fact. It seems like developers spend half of their time bending technology to their purposes when the technology doesn’t really quite fit. Well, I’m actually thinking of one problem in particular right now, namely that of validation. Can you think of a more boring topic? There are few, but I think you can agree that it is an extremely important one in business software.

  • Compilation and Deployment in ASP.NET 2.0

    Magazine/Issue: CoDe Magazine, 2006 - Sep/Oct
    Release Date: Friday, August 18, 2006
    Quick ID: 0609061
    It’s crucial to understand how your ASP.NET code compiles in order to debug your Web applications effectively. ASP.NET 2.0 has changed the way compilation and deployment works, and in this article I’ll dig in and show you how compilation works now and what has changed from ASP.NET 1.x.

  • .Finalize(): Try and Ye Shall Succeed

    Magazine/Issue: CoDe Magazine, 2006 - May/Jun
    Release Date: Tuesday, April 11, 2006
    Quick ID: 0605111
    May/June 06 Finalize Column

  • eXtreme .NET

    Magazine/Issue: CoDe Magazine, 2005 - May/Jun
    Release Date: Wednesday, April 20, 2005
    Quick ID: 0505101
    Learn how to use XP (eXtreme Programming) techniques to improve the way you deliver softwareIn my book, "eXtreme .NET," I introduce a team of developers who are learning how to improve their ability to deliver great software. In this article, you'll follow this team as they learn about a new tool to help them develop software solutions using the .NET Framework. The tool they are going to explore is called Cruise Control and it helps the team continuously integrate their code.

  • Unit Testing Overview

    Magazine/Issue: CoDe Magazine, 2004 - November/December
    Release Date: Wednesday, October 20, 2004
    Quick ID: 0411031
    Utilize unit testing in your Visual Studio .NET development. Automated unit testing enables a team to exercise its entire code base against a battery of tests. This facilitates a quick, reactive environment by providing instant feedback during development. Changes to the code will be tested for validity and any errors will become apparent. Your code will become simpler and you will have great example documentation for using your code.

  • Unit Testing in .NET

    Magazine/Issue: CoDe Magazine, 2004 - November/December
    Release Date: Wednesday, October 20, 2004
    Quick ID: 0411051
    You have been given the task of creating some business objects for a new .NET project.The UI has not been created (or designed) yet, so you start coding right away. After creating the first few objects, you decide that maybe you should do some unit testing. How?

  • Instrumenting Applications with .NET Tracing

    Magazine/Issue: CoDe Magazine, 2004 - September/October
    Release Date: Friday, August 20, 2004
    Quick ID: 0409081
    Application instrumentation gives you the ability to perform runtime diagnosis of enterprise application state, which is critical to mission success.To help with instrumentation and logging, .NET ships with tracing types in the System.Diagnostics namespace. Using these types, you have the ability to log information to multiple output streams for diagnosis of application runtime behavior. Information produced by instrumentation and tracing types enable you to examine the runtime state of an application and fix problems that would be otherwise expensive and painful to solve.

  • The Enterprise Instrumentation Framework

    Magazine/Issue: CoDe Magazine, 2003 - November/December
    Release Date: Monday, October 27, 2003
    Quick ID: 0311091
    We've all faced those irritable questions about our applications running in production. Typically a system administrator will spring one on you on a Friday afternoon just when you're finishing out the week with a game of foosball. Why did this request fail? What is causing so many disk IO spikes? What requests are failing as a result of this error? Why is the application running so slowly? Why are all the resources being gobbled up on the Web server? These questions often make us stare blankly for a while, mumble something, and then scramble back to our cave (or server room) for hours on end trying to provide answers,

  • Maximizing Your Testing Results

    Magazine/Issue: CoDe Magazine, 2002 - Jan/Feb
    Release Date: Saturday, December 15, 2001
    Quick ID: 0201051
    Testing computer software is more than just randomly executing portions of the software.Professional-level testing uses industry-accepted practices to write tests that are the most likely to find bugs. This article will examine how to use a combination of several common testing methods to maximize the results of the time you spend on testing.

  • Introduction to Gathering Requirements and Creating Use Cases

    Magazine/Issue: CoDe Magazine, 2001 - Issue 2
    Release Date: Sunday, April 15, 2001
    Quick ID: 0102061
    Studies indicate that between 40% and 60% of all defects found in software projects can be traced back to errors made while gathering requirements.This is huge! Finding problems while they are just in the planning stages is MUCH easier to deal with than finding them after the code has been written. So, how can developers avoid these errors and create a solid design for their software? This article will describe various methods for gathering software requirements and writing Use Cases - the first two steps in the software development process.

  • Load Testing Web Applications using Microsoft's Web Application Stress Tool

    Magazine/Issue: CoDe Magazine, 2000 - Spring
    Release Date: Saturday, April 15, 2000
    Quick ID: 0001091
    Microsoft's Web Application Stress Tool provides an easy way to simulate large numbers of users against your Web application.This tool makes it possible to make intelligent decisions about hardware and software load incurred by your application and how much traffic a given machine or group of machines can handle. In this article Rick shows how the tool works and how to properly interpret the performance data it generates.


 

Instantly Search Terabytes Of Text
“Lightning Fast”
– Redmond Mag
“Covers all data
sources” – eWeek
25+ fielded & full-text search options
dtSearch’s own document filters highlight hits in popular file types
Web Spider supports static & dynamic data
APIs for .NET, Java, C++, SQL, etc.
Win / Linux (64-bit & 32-bit)
www.dtSearch.com
 

  CODE Training


DevTeach