11. Explain the differences in the following two machine recovery schemes. Comme

Question

11. Explain the differences in the following two machine recovery schemes. Comment on their implementation requirements, advantages and shortcomings, and application potentials.

(a) Recovery of a PM failure by another PM.

(b) Recovery of a VM failure by another VM.

(c) Suggest a method to recover a VM from a failing PM

13. Design a large- scale virtual cluster system. This project may need three students to work together cooperatively for a whole semester. The functional requirements are as follows:

(a) Users can create multiple VMs at one time. Users can also manipulate and conjure multiple VMs at the same time.

(b) Common software such as operating systems or libraries can be preinstalled as templates. These templates enable users to create a new execution environment rapidly.

(c) Users have their own profiles, which store the identification of data blocks for the corresponding VMs in the virtual cluster. New blocks should be created when users modify the data. The identifications for recently created blocks should be inserted into the profiles of the users

Explanation / Answer

Virtual Machine is a completely separate individual operating system installation on your usual operating system. It is implemented by software emulation and hardware virtualization.

Virtual machine is a software implementation of a physical machine - computer - that works and executes analogically to it. Virtual machines are divided in two categories based on their use and correspondence to real machine: system virtual machines and process virtual machines. First category provides a complete system platform that executes complete operating system, second one will run a single program.

Frequently multiple virtual machines with their own OS's are used in server consolidation, where different services are run in separate virtual environments, but on the same physical machine.

The main advantages of virtual machines:

The main disadvantages:

Virtualization brings you a number of advantages – centralizing network management, reducing dependency on additional hardware and software, etc. But as it is always the case, it has certain shortcomings too. Virtualization programs such as VMWare, ESX, Microsoft Hyper-V, do not feature USB and serial ports in virtual machines, i.e. you cannot access USB or serial devices physically plugged into a host machine on virtual server. How do you solve this problem?

How to access hardware devices in virtual machines

USB Network Gate and Serial to Ethernet Connector – enable you to redirect respectively USB and serial ports to virtual environments (VMWare, ESX, Microsoft Hyper-V, Virtual PC, etc.).

USB Network Gate allows you to attach a USB device to a guest OS running on Virtual Server. How do you do it? Install the application on the host OS of a computer in your network and share access to a USB device attached to it. Then install USB Network Gate on the guest OS of the computer that needs to access the device. The application allows USB pass-through to the guest OS running on Virtual Server, i.e. you can connect to the shared device. The OS will see the device as a real one and it will allow you to use it as it were connected directly to your machine. USB Network Gate supports Windows, Linux and Mac.

Serial Port Redirector (Serial to Ethernet Connector from Eltima) allows transferring serial-port data to a guest OS of a virtual machine. It redirects a serial port from the local machine to a virtualization system. Here too, you will need to install the application both on the host computer and the guest OS. This will enable a virtual machine to access a serial port device, as if it were physically attached to it. Serial to Ethernet Connector is available for Windows and Linux.

Nonfunctional Requirements Nonfunctional Requirements (NFRs) define system attributes such as security, reliability, performance, maintainability, scalability, and usability. They serve as constraints or restrictions on the design of the system across the different backlogs. Also known as system qualities, nonfunctional requirements are just as critical as functional Epics, Capabilities, Features, and user Stories. They ensure the usability and efficacy of the entire system. Failing to meet any one of them can result in systems that fail to satisfy internal business, user, or market needs, or that do not fulfill mandatory requirements imposed by regulatory or standards agencies. NFRs are persistent qualities and constraints that, unlike functional requirements, are typically revisited as part of the Definition of Done (DoD) for each Iteration, Program Increment (PI), or release. NFRs exist at all SAFe backlog levels: Team, Program, Large Solution, and Portfolio. Proper definition and implementation of NFRs is critical. Over-specify them and the Solution may be too costly to be viable; under-specify or underachieve them and the solution will be inadequate for its intended use. An adaptive and incremental approach to exploring, defining, and implementing NFRs is a key skill for Agile teams. Details One way to think about all the types of requirements that affect a solution’s overall fitness for use has been the traditional industry categorization of Functionality, Usability, Reliability, Performance, and Supportability (FURPS) [5]. Functional requirements are largely expressed in user stories and in features and capabilities. This is where most of the work occurs; teams build systems that deliver functional value to the user, and most of the time and effort in solution development is devoted to that. FURPS is the placeholder for nonfunctional requirements. Although they may be a bit subtler, NFRs are just as important to system success. NFRs can be considered constraints on new development, in that each eliminates some degree of design freedom for those building the system. For example: “We need to implement SAML-based single sign-on (SSO) for all products in the suite.” (SSO is a functional requirement. Technology based on SAML is a constraint.) NFRs can cover a wide range of business-critical issues that are often poorly addressed by functional requirements. As a reminder to system designers, a fairly comprehensive list of such potential requirements is described in [1]. NFRs Occur at All Levels NFRs are associated with backlogs at all four configurations of SAFe, as Figure 1 illustrates. Figure 1. Nonfunctional Requirements occur at all four configurations Because NFRs are significant attributes of the solution that the Agile Release Train (ART) and Value Streams create, their most obvious representation is at the program and large solution levels. System and Solution Architect and Engineering are often responsible for defining and refining these NFRs. All teams must be aware of the special attributes they’re creating for the system. Accelerating NFR testing, rather than postponing it, helps foster Built-In Quality practices. Teams include the relevant NFRs into their DoD, use them as constraints on local design and implementation decisions, and take responsibility for some level of NFR testing on their own. Otherwise, the solution may not satisfy key NFRs, and the cost of correction that occurs late in the process can be very high. In addition, team-level NFRs can also be important, as they create constraints and performance requirements on the features and the subsystems that emerge. The portfolio level may require certain NFRs as well. This is often the case for cross-system qualities, like the single sign-on case. Other examples include restrictions on open source usage, common security requirements, and regulatory standards. If a specific portfolio-level NFR hasn’t been achieved, it may require architectural Enablers to implement it. In other cases, portfolio-level NFRs may naturally appear in business and enabler epic success criteria. NFRs as Backlog Constraints In SAFe, NFRs are modeled as backlog constraints, as is illustrated in Figure 2. Figure 2. A backlog with Nonfunctional Requirement constraints More technically, the SAFe Requirements Model specifies that NFRs may constrain zero, some, or many backlog items. Further, in order to know that the system is compliant with the constraint, most NFRs require one or more system qualities tests, as is illustrated in Figure 3. Figure 3. Association between backlog items, Nonfunctional Requirements, and system qualities tests Many NFRs begin their lives as enablers that need to be addressed. After that, they constrain the system and all new backlog items going forward. The Systemic and Economic Impact of NFRs on Solution Development Nonfunctional requirements can have major impact on solution development and testing. NFRs are tricky to specify; it’s easy to go overboard. For example, a statement like “99.999 percent availability” may increase development effort exponentially more than “99.98 percent availability.” Sometimes that’s necessary, and other times it’s not. But the impact of the NFR must be well understood by those writing the specifications. Similarly, if not given enough thought, physical constraints such as weight, volume, or voltage may cause the solution to be overly complicated and costly. The Economic Framework of the solution should contain criteria to evaluate NFRs. NFRs should be viewed in the context of trade-offs with costs and other considerations. NFRs also affect Suppliers, as declaring them incorrectly, or without the full trade-off ramifications of the economic framework, could lead to unnecessarily complex and costly systems and components. It’s also important to reevaluate NFRs regularly. Unlike other requirements, NFRs are persistent constraints on the backlog, rather than backlog items themselves. As a result, they may not always come up during PI Planning. But NFRs do change during development, and it’s important to ensure they are addressed. NFRs and Solution Intent Solution Intent is the single source of truth about the solution. As such, it includes NFRs as well as functional requirements. It also includes links between NFRs, requirements they impact, and tests used to verify them. NFRs play a key role in understanding the economics of fixed versus variable solution intent. Figure 4. Solution Intent Early on, some of the functionality is unclear and will need to be tested and negotiated with Customers during development. The same goes for NFRs. Some are fixed and well known in advance; others will evolve with the solution. By imposing constraints, NFRs may impact a wide range of system functionality. Therefore, they’re an important factor in Agile analysis: Analyzing business epics, capabilities, and features Planning and building the Architectural Runway Refactoring to better reflect increasing solution domain knowledge Imposing DevOps constraints by manufacturing, deployment, support, installation, maintainability, etc. The tools used to help develop solution intent provide some mechanisms to establish an economic approach to define and implement NFRs: Compliance – This is the proof that the system or solution meets regulatory, industry, and other relevant standards and guidelines Model-Based Systems Engineering (MBSE) – MBSE can be used to simulate the effect of NFRs and can link to the tests that validate them Set-based Design (SBD) – SBD provides different options for achieving NFRs and can guide a range of edge-case testing to support design decisions Specifying NFRs Considering the following criteria helps define NFRs: Bounded – When they lack bounded context, some NFRs are irrelevant (or even harmful). For example, performance considerations can be extremely important for the main application but unnecessary or too expensive for administration and support applications. Independent – NFRs should be independent of each other so that they can be evaluated and tested without consideration of or impact from other system qualities. Negotiable – Understanding NFR business drivers and bounded context mandates negotiability. Testable – NFRs must be stated with objective, measurable, and testable criteria, because if you can’t test it, you can’t ship it. Implementation Approaches Many NFRs prescribe that some additional work must be done—either now or in the future—to satisfy them. Sometimes the NFR must be implemented all at once; other times the teams can take a more incremental approach. The trade-offs described in the economic framework should impact the implementation approach. Implementation should be built in a way that will allow several learning cycles to ascertain the right level of NFR. All at once – Some NFRs appear as new, immediate concerns and just have to be implemented immediately. For example, a new regulatory rule for derivative trading, if not immediately accommodated, could take the company completely out of the market or cause a regulatory violation. Incremental story-by-story path – At other times, the teams have options. For example, the need for substantially improved performance can be dealt with over time, one story at a time, as Figure 5 illustrates. Figure 5. Introducing a Nonfunctional Requirement to the solution incrementally NFR implementation is also impacted by the way ARTs have been organized. ARTs built around architectural layers will find it challenging to implement and test an NFR in its entirety. ARTs organized around capabilities, however, will find it easier to implement, test, and maintain systemic NFRs. Using Agile Architecture, which provides a combination of intentional architecture and emergent design, supports the development of NFRs and helps maintain flexibility as the requirements evolve. Testing Nonfunctional Requirements Of course, in order to know that a system meets NFRs, it must be tested against them. Testing NFRs is most easily viewed from the perspective of the four Agile testing quadrants, as shown in Figure 6 [2, 3]. Figure 6. Agile testing quadrants (adapted from (2) and (3)) Quadrant 4, System Qualities Tests, is the home of most NFR tests. Due to their scope and importance, NFR tests often require collaboration between the System Team and the Agile Teams. To prevent the growth of unexpected technical debt, teams should automate wherever possible, so that these tests can be run continuously, or at least on demand. Over time, however, the increasing number of regression tests, even when automated, may consume too much processing time and too many resources. Worse, it can mean that NFR testing may be practical only on occasion or only with specialty resources or personnel. To ensure practicality and continuous use, teams often need to create reduced test suites and test data, as illustrated in Figure 7. Figure 7. Collaboration of the System Team and Agile teams to create a more practical Nonfunctional Requirement testing strategy Although partial testing sounds less than ideal, it can actually be beneficial in increasing system quality: When teams are able to apply reduced test suites locally, they may spot inconsistencies in the test data or the testing approach Teams may create new and unique tests, some of which may be adopted by the System Team to help build the larger set Testing infrastructure and configurations will likely improve continuously Teams gain a practical understanding of the impact of NFRs, which helps improve estimating of business and architectural features Even so, in some cases the environment where the NFRs can be tested may not be available on a daily basis (ex., field testing of vehicle guidance software). In these instances, the following approaches can be used [4]: Using virtualized hardware Creating simulators Creating similar environments

Read more at: http://www.scaledagileframework.com/nonfunctional-requirements/
Copyright © 2010-2017 Scaled Agile, Inc.
Request permission to use text and graphics: http://www.scaledagile.com/permissions-form/

Related Questions

Navigate

• Browse (All)
• Browse 1
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.