However, an issue I see with this system is when you have papers for the same day but different months, so it would be a good idea to have individual clear pockets in the section. You can forward plan putting notes in your diary and then the paperwork is placed in the Bring Forward File to back things up.

On this page: Download: -,, Testing is a vital part of software development, and it is important to start it as early as possible, and to make testing a part of the process of deciding requirements. To get the most useful perspective on your development project, it is worthwhile devoting some thought to the entire lifecycle including how feedback from users will influence the future of the application.

The tools and techniques we've discussed in this book should help your team to be more responsive to changes without extra cost, despite the necessarily wide variety of different development processes. Nevertheless, new tools and process improvements should be adopted gradually, assessing the results after each step. Testing is part of a lifecycle. The software development lifecycle is one in which you hear of a need, you write some code to fulfill it, and then you check to see whether you have pleased the stakeholders—the users, owners, and other people who have an interest in what the software does.

Hopefully they like it, but would also like some additions or changes, so you update or augment your code; and so the cycle continues. This cycle might happen every few days, as it does in Fabrikam's ice cream vending project, or every few years, as it does in Contoso's carefully specified and tested healthcare support system. Continuous improvement In the aircraft project, there are many iterations of development between each release of working software; in the web project, there are fewer—or maybe none.

In continuous deployment, each feature released as soon as it is done. The study of this cycle has come to be called 'devOps.' Like so many methodological insights, the point is not that we've just invented the devOps cycle; software systems have always had next versions and updates, whether the cycles take years or hours. But by making the observation, we can evaluate our objectives in terms of a perspective that doesn't terminate at the point of the software's delivery. For example, we can think about the extent to which we are testing not just the software, but the business process that surrounds it; and what we can do to monitor the software while it is operational; and how we adopt software that is already in a devOps cycle. Testing the business process Don't forget that your application is just a part of something that your users are doing, and that their real requirements are about that process.

Whether they are making friends, buying and delivering ice cream, or running an oil refinery, the most important tests are not about what's displayed on the screen, but about whether the friends are kept or offended, the ice cream is delivered or melted, and the oil cracked or sent up in flames. Testing critical or embedded software involves setting up test harnesses that simulate the operation of the factory, aircraft, or phone (as examples). The harness takes the system through many sequences of operation and verifies that it remains within its correct operational envelope. This is outside the scope of this book, beyond noting that simulation isolates the system just as we discussed isolating units in Chapter 2, '.' For less critical systems, and tools that depend heavily on the behavior and preferences of their users, the only real way to test the process surrounding your application is to observe it in operation. Operational monitoring There are two aspects to operational monitoring: monitoring your system to see if it behaves as it should; and monitoring the users to see what they do with it.

What you want to monitor depends on the system. A benefit of bringing the testing approach into the requirements discussions is a greater awareness of the need to design monitoring into the system from the start.

If your system is a website on Internet Information Services (IIS), then you can use the IntelliTrace feature of Visual Studio to log a trace of method calls and other events while it is running. For the default settings, the effect on performance is small, and you can use the trace to debug any problems that are seen in operation. To use this, download the. You can use Visual Studio Ultimate to analyze the trace later. Shortening the devOps cycle Testing allows you to go around the cycle more rapidly. Instead of consulting the customers, you can push a button and run the tests. Rapid devOps cycle with test as a proxy for stakeholders Of course, tests are no real substitute for letting the clients try the software.

But tests can do two things more effectively. Automated tests (and, to a lesser extent, scripted tests) can check very rapidly that nothing that used to work has stopped working. Manual tests—especially if performed by an experienced tester—can discover bugs that ordinary clients would take much longer to find, or which would be expensive if they appeared in live operation. Feedback from tests and stakeholders reduces the risk that you are producing the wrong thing.

To reduce the waste of going down wrong tracks, run tests as early as possible, and consult with your clients as frequently as possible. Updating existing code If you're updating a system that exists already, we hope there are tests for it and that they all pass. If not, you need to write some. Write tests around the boundary of the part that you want to change. That is, write tests for the behavior that will not change, of the components that will change.

For example, if you're thinking of just replacing a single method with something that does the same job more efficiently, then write a unit test for the behavior that should be exhibited by both old and new methods. If, on the other hand, you're thinking of rewriting the whole system, write system tests for the system features that will not change. The same approach applies whether you write coded tests or manual test steps. Make sure the tests pass before you make the changes to the code.

Then add tests for the new or improved behavior. After the updates to the code, both sets of tests should pass. Testing in the development cycle Methodologies vary, and your own project will be different, as we mentioned.

But in any case, there is a role for testing in every phase of your project and throughout the lifetime of the application. Let's now take a look at those roles in at different stages in a project's life. Tests are executable requirements No matter what methodology you follow, it's a fundamental truth that the system tests are the requirements—user stories, product backlog items, use cases, whatever you call them, rendered into executable form. The requirements might change from day to day. Quite likely, they will change when you ask about some fine detail of a test you are writing.

Therefore: • Create a test suite from each requirement. Create test cases to cover a representative sample of cases. In each test case, write the manual test steps or the automated test code to exercise one particular scenario. Parameterize it to allow a variety of inputs. • Cover both functional and quality of service(QoS) requirements. QoS requirements include security, performance, and robustness.

• Include unstated requirements. Many of the QoS requirements are not explicitly discussed. Your job as a tester is to make sure these aspects are covered. • Discuss the test cases with the stakeholders. The relationship between requirements and tests is not one-directional. Your need to make precise tests helps to clarify the requirements, and feeds back into them.

Much of the system's behavior was not explicitly specified. Did the client actually state that they didn't want a picture of a whale displayed when the users buy an ice cream? Is it desirable behavior? Perform exploratory testing to discover what the system does. • Automate important tests gradually. You need to repeat tests for later iterations, later releases, and after bug fixes or updates.

By automating tests, you can perform them quickly as part of the daily build. In addition, they're repeatable—that is, they reliably produce the same results each time, unless something changes.

• Don't delay testing. Test as soon as the feature is available. Plan to write features in small increments (of no more than a few days) so that the lag between development and testing is short.

• System tests are the arbiter of 'done.' No one goes home until there are automatic or manual tests that cover all the requirements, and all the tests pass. This applies to each feature, to each cycle in your process, and to the whole project. ('No one goes home' is a metaphor. Do not actually lock your staff in; to do so may be contrary to fire regulations and other laws in your locality.) Inception At or near the inception of the project, sometimes called Sprint 0, you will typically need to: • Set up the test infrastructure. Build the machinery, the services, the service accounts, the permissions, and other headaches, source control, builds, labs, VM templates.

See the, or, (even better) talk to someone who has done it before. • Make sure you know what you're doing. Get the team together and agree on the practices you're going to follow. Start with what everyone knows, and add one practice at a time. If all else fails, make them read this book, and Guckenheimer & Loje as well.

• Create or import and run tests for existing code. If you are updating existing code, make sure you have the existing manual or automatic tests. If it was created via Visual Studio application lifecycle management processes, it will be easy. • Understand what the stakeholders want. Spend a lot of time with the clients and developers.

Together with them, write down business goals and values; create slide shows of user scenarios; write down user stories; and draw business activity diagrams, models of business entities and relationships, and diagrams of interactions between the principal actors. • Understand the architecture. Spend time with the developers.

Work out the principal components of the system, and the dependencies on external systems such as credit card authorities. Discuss how each component will be tested in isolation as it is developed. Understanding how the system is built tells you about its vulnerabilities. As a tester, you are looking for the loose connections and the soft bits. • Draft the plan. The product backlog is the list of user stories, in the order in which they will be implemented.

Each item is a requirement for which you will create a test suite. At the start of the project, the backlog items are broad, and the ordering is approximate. Simulator Spiele Kostenlos Downloaden Vollversion Pc more.

They are refined as the project progresses. Product backlog items (PBIs) are named and described in terms that are meaningful to stakeholders of the project, such as users and owners. They are not described in implementation terms. 'As a customer I can order an ice-cream' is good; 'A customer can create a record in the order database' is bad. Each item also has a rough estimate of its cost in terms of time and other resources. Remind team members that this should include the time taken to write and run unit tests and system tests. (And while you're there, mention that any guidance documents that might be required should be factored in to the cost as well, and that good technical writers don't come cheap.

On the other hand, if user interfaces were always as good as they could be, help texts and their writers would arguably be redundant.) Each sprint A development plan is typically organized into iterations, mostly called sprints, even in teams where the Scrum methodology has not been adopted wholesale. Each sprint typically lasts a few weeks.

At or near the beginning of each sprint, a set of requirements is picked from the top of the product backlog. Each item is discussed and clarified, and a collection of development tasks is created in Team Foundation Server. You create test suites for each requirement. Early in the sprint, when the developers are all heads-down writing code, testers can: • Write test cases for system tests. Create test steps. If there are storyboard slide shows, write steps that work through these stories.

Writing down the steps in advance is important: it avoids a bias towards what the system actually does. • Automate some of the manual tests from previous sprints. Automate and extend the important tests that you'll want to repeat.

These tests are used to make sure features that worked before haven't been broken by recent changes to the code. Add these tests to the daily builds. When the developers check in working features: • Perform exploratory tests of the new features. Exploratory testing is vital to get a feel for how the product works, and to find unexpected behaviors. From exploratory tests, you will usually decide to write some new test cases. • Perform the manual scripted test cases that you planned for the new requirements.

(Anyone can log bugs—testers, developers, product owners, and even technical writers.) • A bug should initially be considered part of what has to be done for the current iteration. If a bug turns out to need substantial work, discuss it with the team and create a product backlog item to fix it. Then you can put that into the usual process of assigning PBIs to iterations. Towards the end of the sprint: • Run important manual tests from previous sprints that have not yet been automated, to make sure those features are still working. • Start automating the most important manual tests from this sprint. At the end of the sprint: • System testing is the primary arbiter of 'done' for the sprint. The sprint isn't complete until the test cases assigned to that sprint all pass.

Test activities within sprints Using plans and suites A test plan represents a combination of test suites, test environment, and test configuration. Create a new test plan for each iteration of your project. You can copy test suites from one to another. If you want to run the same tests on different configurations, such as different web browsers, create a test plan for each configuration. Two or more plans can share tests, and again you can copy suites from one plan to another, changing only the configuration of the test environment in the Test Plan's properties. Test plans and suites within sprints You can, in essence, branch your test plan by performing a clone operation on your test suites.

The cloning operation allows your team to work on two different releases simultaneously. Reports The project website provides a number of graphical reports that are relevant to testing. The choice of reports available, and where you find them, depends on the Team Foundation Server project template that your team uses. See and its children on MSDN.

Test plan progress report This graph summarizes the results of tests in a chosen test plan, over time. The graph relates to one iteration. Worry if the green section is not increasing. It should be all green towards the end of the iteration. The total number of test cases is represented by the total height of the graph.

If your practice is to write a lot of test cases in advance, you should see a sharp rise followed by a relatively flat section. Number of test points User story test status The user story test status report is a list of requirements that are scheduled to be implemented in the current iteration, showing the results of the tests linked to each requirement. Worry if one of the requirements shows an unusually short line. The requirements should be roughly balanced in terms of how many tests they have—if not, break up the larger ones. Worry if there is a large red section.

By the time the requirements are manually tested, they should be mostly passing. Worry if the chart isn't mostly green towards the end of the iteration. User story test status Test case readiness When you plan a test case, you can set a flag that says whether it is Planned or Ready.

The purpose of this is simply to make it easy to see what stage the tests are in, if the practice on your team is to work out test case steps in advance. At the start of an iteration, you create test cases from requirements, just with their titles. Then you spend some time working out the steps of the test cases. When the steps are worked out and the code is ready, the tests can be run. This chart shows the state of the test cases for the iteration. On the other hand, if your practice is to generate most test cases from exploratory tests after the code is ready, you might find this chart less useful.

Test case readiness Process improvements To summarize the points we've discussed, here are some of the improvements Contoso could consider making to their development process. Any change should be made one step at a time, and assessed carefully before and after. • When you are discussing scenarios, user stories, or other requirements, think of them sometimes in terms of how you will test them. Tests are executable requirements.

Discuss test cases with stakeholders as one way of clarifying the requirements. • Think about validating not only the system but the business process around it. How will you verify that the user really did get and enjoy the ice cream? How will you use the feedback you get? • Create requirement and test case work items in your team project, and write out the steps of some key test cases. This provides a clear objective for the development work. • Write unit tests and aim for code coverage of 70-80%.

Try to write at least some of the tests before the application code. Use the tests as a means to think about and discuss what the code should do. Principles Of Supply Chain Management Rapidshare Search. • Use fakes to isolate units so that you can test them even if units they depend on aren't yet complete.

• Set up continuous build-test runs, and switch on email alerts for failing tests. Fix build breaks as soon as they occur.

Consider using gated check-ins, which keep the main source free of breaks. • Plan application development as an iterative process, so that you get basic demonstrable end-to-end functionality early on, and add demonstrable functionality as time goes on. This substantially reduces the risks of developing something that isn't what the users need, and of getting the architecture wrong.

Unit tests make it safe to revisit code. • Set up virtual labs to perform system tests. • Run each test case as soon as you can. Whenever a build becomes available, perform exploratory testing to find bugs, and to define additional test cases.

• Record your actions when you run manual test cases. In future runs, replay the steps. This allows you to run regression tests much more quickly. • Use the one-click bug report feature of MTM with environment snapshots, to make bugs easier to reproduce.

• Automate key manual tests and incorporate them into fully automated builds. This provides much more confidence in the system's integrity as you develop it. • If your team doesn't distinguish the roles of test and development, consider identifying the people who are good at finding bugs, and get them to focus for some of the time on exploratory testing. Ask them also to think about test planning. • In teams that do separate the developers and testers, consider mixing them up a bit. Involve test leads in the requirements process, and bring developers in to help automate tests.

Thinking of requirements in terms of tests helps to make the requirements more exact What do we get by testing this way? Faster response to requirements changes and bug reports.

• Because you have automated many regression tests and can quickly replay others, testing is no longer an obstacle to releasing an update. Manual testing is only required for the new or fixed feature. With virtual lab environments, you can begin testing very quickly. So let's fix that back-button bug, run the regression tests overnight, and release in the morning. • Stakeholders can experiment and tune their systems. For example, the ice cream vendors need not speculate about whether customers would like to advertise their favorite flavors on a social networking site; they can try the idea and see whether it works. Reduced costs through less waste.

• Unit tests and automated system tests make it acceptable to revisit existing code because you can be confident that you will find any accidental disturbances of the functions you already have working. This means that instead of finishing each piece of code one at a time, you can develop a very basic working version of your system at an early stage. If your architecture doesn't work as well as you'd hoped, or if the users don't like it as well as they'd thought, you avoid spending time working on the wrong thing. Either you can adjust the project's direction, or, at worst cancel at an early stage. • Fewer 'no repro' bugs. The action recording feature of Microsoft Test Manager automatically logs the steps you took in your bug report.

Fewer arguments among team members. Happier customers. • By getting regular feedback, you allow your users to try out the system and tune both their process and what they want of the system. The end product is more likely to fit their needs.

• When your stakeholders ask for something different, or when they report a bug, you can improve or fix your system quickly. What to do next We hope you've got some ideas from this book that will help you and your team develop software that satisfies your clients better and faster and with less pain to you. Maybe you're like Fabrikam and already have these practices and tools in daily use; maybe you feel your company is more like Contoso and you feel there are a number of improvements that can be made. Most likely, you're like us: as we look around our company, we can see some parts that have very sophisticated testing and release practices, and other parts that are still thinking about it. Organizations learn and change more slowly than individuals. Partly this is because they need time to achieve consensus.

Each person's vision of the way forward might be good and effective if implemented across the team, but chaos comes from everybody following their own path. Partly it's because, with substantial investments at stake, it's important to take one step at a time and assess the results of each step. You must not only have a vision of where you want to get to, but also form an incremental plan for getting there, in which each step provides value in its own right. In this book we've tried to address that need. The plan of the book suggests a possible route through the process of taking up the Visual Studio testing tools, and the adaptations in your process that you can achieve along the way. In this book, we've advocated using the Visual Studio tools to automate your testing process more, and we've shown different ways you can do that.

That should make it possible to do regression tests more effectively and repeatably, while freeing up people to do more exploratory testing. We've also recommended you bring testing forward in the process as far as you can to reduce risk, and to make defining tests part of determining what the stakeholders need. In consequence, you should be able to adopt a process that is more responsive to change and satisfies your clients better. But whatever you do, take one step at a time!

The risks inherent in change, and the fear of change, are mitigated by assessing each change as you go. The above cartoon is reproduced with permission from the creator, Hans Bjordahl.

See for more Bug Bash cartoons. Where to go for more information There are a number of resources listed in text throughout the book.

These resources will provide additional background, bring you up to speed on various technologies, and so forth. For your convenience, there is a online that contains all the links so that these resources are just a click away.

The Bring-Forward System (or sometimes referred to as a BF system) might be an old term for the younger assistant, but the principle is similar to using your Tasks in Outlook: You need to have some sort of system to bring forward items that need to be handled at a future date. I have already spoken about using Tasks in Outlook, but on a recent job interview I was specifically asked if I knew how to use a bring-forward system so I thought I would write about it here. Using Tasks in Outlook is great if what you are bringing forward is in electronic form. If I send an email that has a date I need it by, I just drag and drop the sent email into my Tasks and assign it a reminder date and then it will pop up to remind me that I asked for something. I can then email the person asking them for it or it may be something I promised someone so I can then send it to them. That works great for electronic items, but what if you have a hard copy and need to bring that forward? My preferred method is using hanging folders and arranging them by month.

When you want something later you just put it in your hanging folder for the month you need it. I write the day I want it in the corner of the item or put it on a sticky note (i.e.

Bf for May 13). Every evening before I leave for home I check my bring-forward folders to see what I need for the next day. This is an excellent method when you are bringing things forward for your boss. I then put them in a folder for my boss and leave it on his desk so he has everything he needs for that day.

For my own bring forwards, I use a combination of my Tasks in Outlook and a Wait Bin (or Holding Tray) to bring forward items that need my attention later. Anything I put in my Wait Bin, I put a corresponding Task in Outlook with a reminder referring myself to the Wait Bin. For instance if I need to register my boss for a conference by a certain date and I have a hard copy registration form that needs to be faxed I would it in my Wait Bin and set a Task reminder for the day before I need to send it.

My Task would read something like 'WAITBIN: Register Mr. Brown for Australia Conference.' Then when the reminder pops up I will know the registration form is in the Wait bin. It is really a catch-all system and can be used for anything. An assistant in my office uses index cards in a card box (separated by month) to remind herself of things to do. She writes on the index card what she needs to do that day or a file she needs to bring-forward and she checks the box each day. Please see my earlier article on (August) for more tips on organizing your desk. Here is an article with some ideas about the bring-forward system that might be helpful to you: (accessed October 8, 2007).

Some of us older assistants are very reluctant to only rely on the new technology, as in the case of the woman in my office using the index cards. It actually happened a few year's ago at a place I worked that Outlook crashed for the whole day and everyone lost all their calendar and task information from that day forward. At that time I wasn't using Tasks, but was using a manual system so I wasn't affected, but now I do use Tasks and I'm always a little worried that the same thing might happen. IT_bloke said. For that, you need a regular backup system!

You should be able to set Outlook to export to an open format, either text, HTML or something like that, at the end of every day, to an external drive, CD or similar. If you have IT people in the office they can help with this. I'd make a backup of your Outlook info on your PC's hard disk then copy it to a flash drive (a.k.a. Memory stick) and take it home every night.

Then you have 3 copies: the Outlook files on your PC, the Outlook backup on your PC and the Outlook backup on your flash drive. Ottawa, Ontario, Canada Patricia Robb has been in the administrative field for over 30 years.

Currently she serves as an Administrative Assistant to the Psychiatrist in Chief/Chief of Staff of a mental health hospital. Previously she was a Senior Executive Assistant and Corporate Secretary for a not-for-profit organization and has also spent many years as a legal assistant in various law firms in Ottawa, worked as a secretary for the Royal Canadian Mounted Police and as an admin assistant at an Oilsands Plant in Fort McMurray, Alberta. She is a member of the Ottawa Chapter of the International Association of Administrative Professionals (IAAP) and has held the position of membership chair and board secretary. Patricia also regularly conducts minute-taking webinars for Business Management Daily. She was a hairdresser for 5 years, which she credits in helping her enhance her people skills and in the art of small talk.

You can reach Patricia by e-mail at patriciaannrobb@gmail.com. The opinions expressed in this blog are the author's own views. I am not responsible for the content on any sites I have linked to as a resource or linked to in my articles.

These independent sites are subject to change by their site operators and I have no control over the content on their sites. I am a woman and therefore reserve the right to change my mind and go back and edit my articles from time to time or to update them. I apologize in advance if I offend anyone with my opinions as that is not my intention, especially against those who may have the ability and means to sue me! My opinions are based on experience, education, trial and error and blunders and bloopers made throughout my life and career. I am not a legal expert and do not claim to give any legal advice. I also do not claim to give any medical, financial, psychological, veterinary, retail, personal training or HR advice, although at times it may seem like I think I know what I'm talking about, it is just my opinion.

I am using Canadian English throughout my blog and do not apologize for that, unless I am quoting someone, then I write it as it was quoted. I hope in this disclaimer that I have covered everything that could possibly be construed as inappropriate blogging by my readers, my employer, my co-workers and my family and friends.