All ISTQB CTFL-2018 certification exam dumps, study guide, training courses are Prepared by industry experts. PrepAway's ETE files povide the CTFL-2018 ISTQB Certified Tester Foundation Level 2018 practice test questions and answers & exam dumps, study guide and training courses help you study and pass hassle-free!

2018: Testing Throughout The Software Life Cycle

6. What is Agile?

What is agility? Agile is definitely the latest and coolest buzzword in the software development world. These days, everyone wants to be Azure. But there are many misconceptions of what "Azure" means, and many people don't understand the implications of what it takes to develop an effective Agile development process. It's very important to understand what we are getting ourselves into before taking any steps. First, let's talk about the meaning of the word "agile." Dr. David Rico defined Agile as "the ability to create and respond to change in order to profit in a tough global business environment." It's also the ability to quickly reboot the use of resources when requirements, technology, and knowledge shift or change. It's also a very fast response to sudden multiplier changes and emerging threats through intensive customer interaction. Agile employs evolutionary incremental and innovative delivery to provide the best possible customer solution.

It's also maximizing the business value with just-enough and just-in-time processes and documentation. Agile, from the perspective of project management, is innovative software development with more best practices to deliver software with higher quality at a lower cost in less time by highly motivated people. Well, this is a big one, so let me do this again.

Agile software development is iterative, but with more best practices to deliver higher-quality software at a lower cost and in less time by highly motivated people. We still use the same concept of iteration and continuous delivery of working software to the customer after every iteration. Azure development has become commonplace in the industry. In a recent survey, over 52% of respondents said that the company practised Agile development in one form or another. So that's something that I want you to notice. They said one thing or another. This means that there are various approaches to using Agile in a project. And we will talk about this in detail in future videos. So let's understand Agile from the day it was born.

7. Agile Manifesto

In 2001, a group of very well-known names in the software industry, representing the most widely used lightweight software development methodologies, looked at the software industry and how it advances. As they didn't like what they saw, they looked at the issues and came up with a solution, which they called Agile. They agreed on a common set of values and principles, which became known as the Manifesto for Agile Software Development, or the Agile Manifesto. The Agile Manifesto, in my opinion, is analogous to a country's constitution; it serves as the foundation for all of the country's laws. No law is allowed against the Constitution or the Manifesto. Let's read it together. We are uncovering better ways of developing software by doing it and helping others do it. Through this work, we have come to value individuals and interactions over processes and tools.

Working software over comprehensive documentation, customer collaboration over contract negotiation, responding to change over following a plan that is While there is value in the items on the right, we value the items on the left more. The Agile Manifesto contains four statements of values. Let's look at each one of them in detail. Individuals and their interactions with processes and tools come first. Software projects are people-oriented. Much of our success is based on effective interaction and communication. Even if we have the best processes and tools combined with poor communication, success will be very likely. Processes and tools are, well, tools. They are not the objectives or the goals that we must follow.

They are, after all, tools. Any busy CS and tools should be used to enhance teamwork rather than to replace it. Vertex are developed by people; problems get solved by people; scope is defined or negotiated by people; and, most importantly, projects are accepted by people. Focusing early on developing the individuals involved in the project and emphasising productive and effective interactions helps set up a project for success. Please note that this is not to say that both CCS and tools cannot help in successfully completing a project. This is a common mistake made by companies that are starting to use Agile. They think "agile" means no processes. Our projects are ultimately about people. If we ask two teams to develop the same product, they will produce different outputs.

Yes, it's the same software that helps with the same objective, but the requirement document will be different, the design will be different, and the code will be different. Even how to test the software will be different. Everything will be different. Why? We depend on how people think, which varies from one person to another. Working in software without comprehensive documentation is certainly a problem and will truly hold back support and maintenance. But comprehensive documentation without software is next to nothing for most organizations. Software projects are typically initiated with the goal of creating valuable, high-quality software, right? Even though this is very common sense, Still, we've spent weeks or months writing extensive documentation that doesn't support the ultimate goal of creating software. From the customer's perspective, working software is much more useful and valuable than very detailed documentation.

In addition, because working software is available much earlier in the software development cycle, agile development can provide a significant time-to-market advantage, and it provides an opportunity to give the development team rapid feedback. When I first started learning about waterfall in the 1980s, I had to read thousands of pages to understand what the required documentation was. And of course I had to create or produce those thousands of pages of reports myself. Again, a very common mistake is when people claim that Agile promotes no documentation wrong.

This doesn't mean that we have to avoid documentation completely; only necessary documentation is reduced. And for me, this is an artefact to document only what is necessary. Is it necessary to prove that the format is in both XYZ Time and New York Time? No, I can't see it. So I recorded it in a document. So this means that valuable software will be delivered early and frequently during the development. So in an Agile way of working, we deliver a piece of work in a software increment every iteration.

That means we need to decide what to deliver in every iteration and decide if a specific feature will really add value to the user or not. This value speaks about the need to deliver customer collaboration over contract negotiation. We all should know by now that customers often find great difficulty in specifying the assistance that they require. and this is very natural. My friend. If you are a single person or were once single, could you specify exactly what you want in your future spouse? I doubt it. It's difficult to define precisely an ever-changing vision of what you want to build. Well, you see prototypes, you see this and that, you see different versions, and then you can build from what you saw to get what you are actually looking for. So this value reminds us to be flexible rather than uncooperative. It's similar to the difference between verification and validation. Verification is the right thing to do, and validation is the right thing to do.

Again, we value both verification and validation, but we should value validation over verification. I will explain that we could do verification and testing to build the product exactly as originally specified. But if the customer changes his or her mind or claims that this will not help their business, it would be better to be flexible and work toward their new goal as opposed to the goal that was originally stated. Validation entails doing what the customer wants and doing it correctly. Software products have a dynamic nature.

Software is intangible. Business needs change quickly, and technology changes rapidly. Rather than beat up the customer or management with a very tough change management process, we should recognise at the start that things are going to change, and we should work with the customer throughout the project toward a shared understanding of how to define when something is done.

Collaborating directly with the customer improves the likelihood of understanding exactly what the customer requires. Working in regular and close collaboration with them is likely to bring more understanding and success to the project.

Customers often do not know what they really want until they see something. While working while having contracts with customers is important, agile boomotes have more trusting relationships and flexible contract models than we often see on traditional projects. A perfect motive is lighting contracts with customers, and a purpose motive is collaboration. So purpose and motive should be given more importance than perfect motive.Responding to Changes Rather Than Sticking to a Plan: We all agree that changes are unavoidable in software projects. High rates of change are common in software projects. Many factors might require the change.

These factors must be accumulated during the development process. Also, the initial plans were made when we knew the least about the budget at the beginning of the budget, and as the worker progresses, we will learn more about the work, and we should update the plan accordingly. The flexibility to accumulate changes in the blend is more significant than just writing a blend and following it. We need to acknowledge that things will change and blend smartly again and again.

This doesn't mean that the Azure manifesto is suggesting that we abandon blending and just react to changes. No, we still need to blend, but we need to blend smartly. So the Azure manifesto gets us to consider projects from a value-based perspective. Yes, we will need bosses, tools, documentation, and blends on our projects. Yet while dealing with those assets, we should remember that our focus must be on the people who are using the product that we are building. Collaboration and agility are the abilities to execute projects while focusing our efforts on the items on the left in the Azure manifesto over the items on the right.

8. Scrum

Agile development framework with several key features depicted in the figure, and we will go over each one in detail. Scrum defines three rules. scrum master who ensures that Scrum practises and rules are understood, implemented, and followed and resolves any violations, resource issues, or other barriers that could prevent the team from following the practises and rules. This person is not the team leader but a coach. For me, I consider him more of a quality-assurance person, but that's only my point of view. The product owner represents the customer who is responsible for maximising the value of the product and has the sole responsibility of managing its backlog, including its biology, accuracy, shared understanding, value, and visibility.

Again, this Bearson is not the team leader. The development team is a group of professionals who can fulfil all the roles needed to complete the work and build the product increments. In each iteration, the development team is empowered to manage its own work, and its members are self-organized and functional. They develop and test the bladder.

Again, there is no team leader, so the team makes its own decisions. The Scrum contains the following instruments and practices: Scrum divides a bullet into iterations of fixed lens sprints and a Scrum, and the lens is usually two to four weeks. Every iteration should attempt to build a potentially shapeable and properly tested product increment. The duration of the brand and how long it lasts are decided by the team based on their requirements and capabilities.

Brand duration, once agreed upon, should not be modified, which means if anything unusual happens during the sprint that requires extra time, it should be moved to the next sprint. A sprint is like a mini budget. During the sprint, no changes are made that would affect the sprint goal, although the scope may be clarified or renegotiated as new information becomes available.

Each sprint includes a print planning meeting, daily Scrum development work, a print review meeting, and a print retrospective. We will talk about those events in future lectures. Throughout the sprint product, the development team members remain the same. Each sprint results in a potentially reusable shapeable, product code, and increment. The product owner manages Barbara's list of blend product items in a log called the product backlog. The product backlog is the ordered list of everything that might be needed for the product to be built.

The product backlog serves as the single source for requirements. It is dynamic and evolves as the product evolves (a process called backlog refinement), contains features to be built, functions, requirements, nonfunctional requirements, and fixes, and whatever needs to be done is widely expressed such that each item has value to the users or customers of the product.

The product backlog is managed by the product owner and refined at the start of each iteration. Grooming is the process of adding more detail to the backlog and refining the estimates of the backlog items. Sprint Backlog At the start of each sprint, the scrum team selects a set of the highest priority items from the product backlog and puts them into the sprint backlog, combined with a plan of how to achieve the sprint goal. Since the Scrum team, not the product owner, selects the items to be realised within the Sprint, this selection is referred to as being on the "pull" principles rather than the "push" principles pool principles.

The developer is pulling the items from the product backlog and putting them in this print backlog, not the product owner, who would otherwise bush the item against the developers. This print backlog may only be updated by the development team. Definition of "Done" The team should collectively create the definition of "done" for the items before they begin to work on them. This helps to make sure that there is a potentially reusable product for each brand’s.

Finally, the Scrum team discusses and defines appropriate print criteria. Completion of the discussion debates the team's understanding of the backlog items and the product requirements. Time boxing Time boxes are short, fixed-duration periods of time in which activities or work are undertaken. If the work in the time box is not complete when the time runs out, we stop what we are doing and move the uncompleted work into another time box. Examples of time boxes include daily standup meetings that are time boxed to 15 minutes, iterations that are time boxed to typically two weeks, and so on.

As we mentioned before, only those tasks, requirements, or features that the team expects to finish within the sprint are part of the sprint backlog. If the development team cannot finish a task within a sprint, the associated product features are removed from the sprint and the task is moved back into the product backlog. Transparency The development team reports and updates brand status on a daily basis at a meeting called the Daily Trial.

This makes the content and progress of the current brand, including test results, visible to the team management and any interested parties. For example, the development team can show its status on a whiteboard. It's so simple. Unlike XP, Scrum does not dictate specific software development techniques like paper programming or test-first programming. In addition, Scrum does not provide guidance on how testing has to be done in a Scrum environment. It.

9. Test Levels : Component Testing

In the V-model discussed earlier, there were different test stages. They are often called test levels. Test levels are groups of test activities that are organised and managed together. Each test level is an instance of the test process performed in relation to the software at a given level of development, from individual units or components to complete systems or, where applicable, systems of systems. These levels are related to other activities within the software development lifecycle. The typical levels of testing are unit or component testing, integration testing, system testing, and acceptance testing. Each test level has its own concerns and issues that we need to consider. Test levels are characterised by the following attributes:

Specific objectives test bases are the source from which we can drive test cases for that level of test object, such as what is being tested, typical defects and failures, and specific approaches and responsibilities. To understand the whole idea better, think of building a car. It has a lot of components. Before assembling the car, you need to make sure that each component is working perfectly well by itself. So you run some tests on each component individually.

That's component or unit testing. After making sure that each component is working fine, you'll start adding the components one by one. Before proceeding, you should ensure that any new components work well with the existing ones. So you want to make sure that the newly added component integrates well with the other component. That's integration testing. Now, the hot car is built and looks great, but you must do a test drive and try as many scenarios as possible, like moving uphill to it on a TV road or bombing road. That's system testing. So the car looks great, is beautiful, and works fine, but the buyer still must try it out before purchasing it.

That brings us back to the world of software acceptance testing. Each of these test levels will include tests designed to uncover problems specific to that stage of development. These levels of testing can be applied to any development model, and they may vary depending on the objective of the development model objective. In addition, for every test level, a suitable test environment is required in acceptance testing.

For example, a production-like test environment is ideal, while in component testing, the developers typically use their own development environment for testing. Let's talk about each test level one by one, starting with component testing. Component testing is the lowest level of testing. Also known as unit or module testing, it focuses on components that are usually tested in isolation. Unit testing is usually done by the programmers, as they are the best people to know the code that constructs the component.

So usually, developers alternate component development with finding and fixing defects. Unit testing is intended to ensure that the code written for the unit meets its specifications prior to its integration with other units. Objectives of component testing include reducing the risk of delivering a bad component, verifying whether the functional and nonfunctional behaviours of the component are as designed and specified, building confidence in the component's quality, finding defects in the component, and preventing defects from scaling to higher test levels.

Test basis, as we have mentioned before, are the documents that we use as a basis or reference to perform the testing. Examples of work orders that can be used as test bases for combination testing include a detailed design code data model component specifications test Objects So what do we test while we are doing component or unit testing? The answer is components. Thus, test objects can be components, units, or modules.

Code and data structures—classes, database modules, and components—are small beaters of code developed by developers. Unit testing requires access to the code being tested. Approaches to specification and responsibilities So all we want to do here is make sure that the developer delivers a perfectly working unit and not leave it to the tester to find silly mistakes in a component. Component testing may cover functionality.

In future videos, we will learn more about the correctness of calculations, nonfunctional characteristics (such as searching for mineral leaks), and structural properties (such as decision testing). Component testing is often done in isolation from the rest of the system depending on the software development lifecycle model and the system, which may require Mac objects, services, virtualization harnesses, and drivers. Let me explain what steps and drivers are being used in the car assembly example. Again, some components of the car can be tested in isolation by itself.

But some other components might need some sort of external tools, wires, or maybe external bars to help test a component or piece of software. We call those people helpers and drivers. Imagine if a developer implemented this piece of code to calculate the salary of an ingredient. Don't worry; you don't need to know any programming languages to understand this.

Just go along. In this unit, the developer needs to interact with another component called Calculate Bonus. But unfortunately, this unit is not ready yet. So what should the developer do? Well, he might write or create a fake piece of code and name it Calculate Bonus. It's not the final version, for sure, but it's there only to help the developer test his Calculate Salary unit. So what should he do? Or write in the Calculate bonus code. At the bare minimum, we don't want the new code to produce bugs by itself. So we might let the CalculateBonus code just return 10.

So while we test our Calculate Salary code, we will assume that all employees will receive a $1,000 bonus. In our examples, the concrete bonus piece of code is called Stub. So a stub is a Danny code used for testing in place of a cold component. Now, if we want to test Calculate Salary Goods, we need to write code to run it. It cannot be executed by itself in many languages. The first start point of the software is a function called the main function.

So in our case, we would write a main function to calculate our salary. Now, this main function is written only for testing purposes, and it's called driver. So a driver is a DRAM code used for testing in place of a cooler component. in some cases, especially in incremental and iterative development models. For example, in Agile, where coded changes are ongoing, We would like to save the developers the time of having to do unit testing with every change made manually.

So automated component regression tests play a key role in building confidence that changes have not broken existing components. We automate the way we test when we use automated testing. So the computer would run a script to run the tests for us instead of doing it manually. So far, so good.

Now, I want you to pay attention to what's coming next. As you know, developers will create the components, and then they will test those components. So developers will open up and execute tests after having written the code for a component.

OK? However, there may be some delays in Azure development, particularly when writing automated component tests. Writing application code is part of an approach to development called test-driven development, or TDD. So the developers here start by writing the automated test cases. Then they write the code to fulfil those automated tests. Of course, the first time the developer runs the tests, when there's not actually any code written yet, everything fails.

Developers will then write the code bit by bit and continuously run the automated test scripts, correcting mistakes until finally all the scripts pass, which means coding is done. That's why we call it test-driven development. The tests are the ones that drive our way to development.

Later, the developers can refactor, refine, or clean the code. Projects that use TDD are highly iterative. Test-driven development is an example of test-first development. While test-driven development originated in Extreme Programming (XP), which is one of Azure's resolutions as well, it has spread to other forms of agile and also to sequential life cycles.

You don't need to know much about TDD, as it is explained in detail in the Agile Extension ISTD certificate, so we only need to know that it exists. Typical defects and failures that can be found during component testing are incorrect functionality, for example, not as described in the design specification. Data flow problems or incorrect code and logic defects found during unit tests are often not recorded with formal defect management systems, and developers can fix them instantly.

However, when developers do report defects during component testing, it will be for the purpose of providing important information for root cause analysis and process improvement.

ISTQB CTFL-2018 practice test questions and answers, training course, study guide are uploaded in ETE Files format by real users. Study and Pass CTFL-2018 ISTQB Certified Tester Foundation Level 2018 certification exam dumps & practice test questions and answers are to help students.