Skills required for Microsoft test 70-547

Skills required for Microsoft test 70-547

Rating:

Microsoft has specified more than thirty five objectives for the 70-547 test, which are grouped under six topics. Following are some important areas in which an individual should possess a good knowledge before taking the 70-547 test:

1. Evaluating the technical feasibility of an application design concept.
2. Recommending the best technologies for the features and goals of the application and investigating existing solutions for similar business problems.
3. Creating a proof-of-concept prototype, evaluating the risks associated with ASP.NET 2.0 technology, validating that the proposed technology can be used in an application, and demonstrating to stakeholders that the proposed solution will address their needs.
4. Evaluating the technical specifications for an application to ensure that the business requirements are met, translating the functional specification into developer terminology, and suggesting component type and layer.
   
5. Evaluating the design of a database, recommending a database schema, and identifying the stored procedures that are required for an application.
   
6. Evaluating the logical design for performance, maintainability, extensibility, scalability, availability, security, use cases, recoverability, and data integrity of an application.
7. Evaluating the physical design for performance, maintainability, scalability, availability, security, recoverability, and data integrity of an application.
   
8. Choosing an appropriate layout for the visual interface, deciding the content flow across pages, evaluating user navigation needs, identifying the goal of a page, and ensuring the congruency and consistency of a user experience throughout an application.
   
9. Evaluating a strategy for implementing a common layout throughout the UI, suggesting when to use style sheets, master pages, Web parts, custom controls, scripting, and user controls, and suggesting an applicable UI standard based on the intended client environment.
   
10. Choosing an appropriate control based on design specifications, evaluating the type of data that must be captured or displayed, and evaluating available controls.
11. Evaluating how available controls are implemented in previous and ongoing projects or applications. Evaluating the user demographic and the user environment.
12. Choosing an appropriate data validation method at the UI layer and a validation method based on the data type provided.
13. Deciding how to report a feedback, identifying the source of invalid data and identifying the cause of an invalid entry.
14. Evaluating whether invalid data can be prevented, whether an exception must be thrown, whether an exception must be logged, and whether visual feedback, such as a message box or color is required.
15. Choosing appropriate user assistance and application status feedback techniques, designing a user assistance mechanism.
16. Choosing an appropriate application status feedback technique based on available control types, choosing an appropriate application status feedback technique to support accessibility, and designing an application status feedback mechanism.
    
17. Choosing an appropriate mechanism to deliver multimedia data from an application, evaluating available multimedia delivery mechanisms, and designing a multimedia delivery mechanism.
    
18. Establishing the required characteristics of a component, deciding when to create a single component or multiple components, deciding which tier of the application component should be located, and which type of object to build.
    
19. Creating a high-level design of a component, establishing the life cycle of the component, deciding whether to use established design patterns for the component, and deciding whether to create a prototype for the component.
20. Documenting the design of a component by using pseudo code, class diagrams, sequence diagrams, activity diagrams, and state diagrams, and evaluating trade-off decisions.
21. Developing the public API of a component, deciding the types of clients that can consume a component, establishing the required component interfaces, and deciding whether to require constructor input.
    
22. Developing the features of a component, deciding whether existing functionality can be implemented or inherited, deciding how to handle unmanaged and managed resources.
23. Deciding which extensibility features are required, whether a component must be stateful or stateless, whether a component must be multithreaded, and which functions to implement in the base class, abstract class, or sealed class.
    
24. Developing an exception handling mechanism. Deciding when it is appropriate to raise an exception and how a component will handle exceptions.
    
25. Developing the data access and data handling features of a component, analyzing data relationships, and data handling requirements of a component.
    
26. Developing a component and identifying potential issues, such as resource leaks and performance gaps, by profiling a component. Deciding when to stop profiling on a component and whether to redesign a component after analyzing the profiling results.
    
27. Consuming a reusable software component and identifying a reusable software component from available components to meet the requirements.
28. Identifying whether the reusable software component needs to be extended, wrapped, whether any existing functionality needs to be hidden, and testing the identified component that is based on the requirements.
    
29. Choosing an appropriate exception handling mechanism, evaluating the current exception handling mechanism, and designing a new exception handling technique.
    
30. Choosing an appropriate implementation approach for the application design logic, an appropriate data storage mechanism, an appropriate data flow structure, and an appropriate decision flow structure.
    
31. Choosing an appropriate event logging method for an application. Deciding whether to log data.
32. Choosing a storage mechanism for logged events, choosing a system wide event logging method, and deciding logging levels based on severity and priority.
    
33. Monitoring specific characteristics or aspects of an application. Deciding whether to monitor data, and deciding which characteristics to monitor.
34. Choosing event monitoring mechanisms, such as System Monitor and logs, deciding monitoring levels based on requirements, and choosing a system wide monitoring method from the available monitoring mechanisms.
    
35. Evaluating the application configuration architecture, deciding which configuration attributes to store, and choosing the physical storage location for the configuration attributes. Deciding in which format to store the configuration attributes and when to use ASP.NET Administrative tools.
    
36. Evaluating the unit testing strategy, the integration testing strategy, and the stress testing strategy. Evaluating the performance testing strategy and the test environment specification.
    
37. Designing a unit test. Describing the testing scenarios and coverage requirements. Evaluating when to use boundary condition testing and deciding the type of assertion tests to conduct.
    
38. Performing integration testing and determining if the component works as intended in the target environment, and identifying component interactions and dependencies.
39. Resolving a bug, investigating a reported bug, reproducing a bug, fixing a bug, and evaluating the effect of the bug and the associated cost and timeline for fixing the bug.
40. Evaluating the performance of an application that is based on the performance analysis strategy. Identifying performance spikes, analyzing performance trends, tracking page response times, and tracking logon times.
    
41. Analyzing data received when monitoring an application. Monitoring and analyzing resource usage. Tracking bugs that result from customer activity and choosing when to use ASP.NET 2.0 Health Monitoring APIs.
    
42. Evaluating the deployment plan, identifying component-level deployment dependencies, and scripting requirements for deployment.
    
43. Creating an application flow-logic diagram, evaluating the complexity of components, and evaluating the complexity of interactions with other components.
    
44. Validating the production configuration environment, verifying networking settings and the deployment environment.
    

Rating: