Microsoft 70-481 Test Practice Test Questions, Exam Dumps

File	Votes	Size	Date
File Microsoft.Passguide.70-481.v2013-08-15.by.Riot.67q.vce	Votes 9	Size 3.8 MB	Date Aug 16, 2013
File Microsoft.Certkiller.70-481.v2013-05-12.by.Veleno.63q.vce	Votes 1	Size 3.72 MB	Date May 13, 2013
File Microsoft.Certkiller.70-481.v2013-02-19.by.ta22kid.63q.vce	Votes 1	Size 3.84 MB	Date Feb 19, 2013

element for the primary content area. Using these semantic tags, rather than generic

elements, improves the accessibility and maintainability of the application's code.

The structure of the UI was also heavily influenced by the controls provided by the WinJS library. These were special components, like the ListView or the AppBar, that were created using a combination of HTML

elements with special data-win-control attributes. The developer would define the placeholder for the control in HTML, and then the WinJS JavaScript library would dynamically render the rich, interactive control in that location. A solid understanding of this declarative control model was essential for the 70-481 Exam.

Styling the UI with CSS3

Cascading Style Sheets 3 (CSS3) was the language used to control every aspect of the visual presentation of a Windows Store app. A deep expertise in CSS3 was a critical skill for the 70-481 Exam, as it was the tool used to implement the Modern UI design principles. This went far beyond simple colors and fonts and delved into the advanced capabilities of CSS3 for layout, animation, and creating a touch-friendly experience.

One of the most important aspects of styling was typography. The Modern UI design language placed a strong emphasis on beautiful and readable text. Developers needed to know how to use CSS properties to control font sizes, weights, and styles to create a clear visual hierarchy. The design used a standard "type ramp" with predefined styles for different levels of text, such as headers, subheaders, and body text, and a developer was expected to implement this consistently.

CSS3 was also used extensively for creating the "fast and fluid" feel of the applications. This was achieved using CSS Transitions and Animations. Transitions were used to create smooth visual changes when a property of an element changed, for example, when a button was hovered over or pressed. Animations were used to create more complex, multi-step visual effects. The 70-481 Exam required knowledge of how to define and apply these effects to create an engaging user experience.

The WinJS library also came with a default stylesheet that provided the standard look and feel for the Windows 8 platform. Developers needed to know how to work with this stylesheet, how to override the default styles when necessary, and how to create their own custom styles to match their application's branding. A strong command of CSS selectors, the box model, and styling properties was a fundamental requirement for the visual design portion of the 70-481 Exam.

Creating Adaptive Layouts for Different Devices

A key challenge for any modern application developer, and a central topic for the 70-481 Exam, is creating a user interface that looks great on a wide variety of screen sizes and resolutions. A Windows Store app could be run on a small tablet, a large desktop monitor, or even snapped to the side of the screen in a narrow view. A well-designed app needed to adapt its layout to all of these different "view states."

The primary tool for creating these adaptive layouts was CSS3. The exam required a strong understanding of several key CSS3 layout modules. The CSS Grid Layout and the Flexible Box Layout (Flexbox) were particularly important. These modern layout modules provide a powerful and flexible way to arrange elements on the screen and to control how they grow, shrink, and wrap as the available space changes. A developer needed to be able to use these tools to create fluid and responsive layouts.

Another key technique for creating adaptive UIs was the use of CSS Media Queries. A media query allows you to apply a specific set of CSS rules only when certain conditions are met, such as when the screen width is above or below a certain size. This is the core technology behind responsive web design. For the 70-481 Exam, developers needed to use media queries to change the layout of the application for different view states, such as the full-screen view, the snapped view, and the portrait orientation.

For example, in a full-screen view, an application might display its content in multiple columns. When the same application is snapped to the side of the screen, a media query would be used to change the layout to a single, vertically scrolling column. The ability to write the HTML and CSS to support these different layouts and to handle the transitions between them smoothly was a critical skill for any developer building for the Windows 8 platform.

Working with WinJS UI Controls

While standard HTML5 provides a basic set of input controls, building a rich and interactive application requires a more extensive set of UI components. For the 70-481 Exam, this was provided by the Windows Library for JavaScript, or WinJS. WinJS was a JavaScript library created by Microsoft that provided a rich set of UI controls that were designed to match the look, feel, and behavior of the native Windows 8 Modern UI.

These controls were typically added to the application using a declarative syntax in HTML. A developer would place a

element on the page and then add a data-win-control attribute to it. This attribute would specify which WinJS control to create, for example, WinJS.UI.ListView for a list or WinJS.UI.AppBar for an application command bar. The developer could also specify options for the control using a data-win-options attribute.

Some of the most important WinJS controls that were covered in the 70-481 Exam included the ListView, which was a powerful and versatile control for displaying collections of data in a grid or list format. The AppBar was used to display the application's commands, and it would typically appear from the top or bottom of the screen when the user swiped. The FlipView was used to create a "flip-through" experience for viewing items one at a time, like a photo gallery.

To work with these controls, a developer needed to know not only how to declare them in HTML but also how to interact with them using JavaScript. This included providing the data for the control (e.g., the items for a ListView), responding to events that the control fired (e.g., when an item was selected), and calling methods on the control to change its state. Proficiency with these core WinJS controls was essential for building a functional and native-feeling application.

Implementing Navigation within an App

Unlike a traditional multi-page website, a Windows Store app built with HTML and JavaScript typically operated as a Single-Page Application (SPA). This means that the application has a single main HTML page, and navigation between different "pages" or "views" of the app is handled dynamically using JavaScript. A solid understanding of how to implement this navigation model was a key requirement for the 70-481 Exam.

The navigation model in a WinJS application was centered around a PageControl object. Each logical page of the application (e.g., the home page, the details page) was defined in its own separate HTML, CSS, and JavaScript file. When the user navigated to a new page, the content of that page's HTML file was loaded into a container

on the main default.html page. The associated JavaScript for that page was then executed to bring the page to life.

The WinJS library provided a WinJS.Navigation module to manage this process. This module handled the navigation history, allowing the user to go back to previous pages. A developer would use the WinJS.Navigation.navigate() function to programmatically navigate to a new page, passing the path to the page's HTML file and any data that needed to be passed to the new page.

The application also needed to handle the system's back button, which could be a physical button on a tablet or a button in the UI. The developer was responsible for writing the event handler for this back button and using the navigation history to go back to the previous page. Implementing this entire navigation framework, including passing data between pages and managing the back stack, was a fundamental architectural task for the 70-481 Exam.

Displaying and Formatting Data

A primary purpose of most applications is to display data to the user. The 70-481 Exam required developers to be proficient in various techniques for displaying and formatting data in a Windows Store app. This involved retrieving the data from a source and then "binding" it to the UI elements so that it could be presented to the user in a clear and visually appealing way.

The most common way to display a collection of data items was to use the WinJS ListView control. The ListView was designed to be highly efficient, capable of displaying thousands of items without slowing down the application. To use it, a developer would first create a WinJS.Binding.List object in JavaScript and populate it with the data, which was typically an array of objects.

Next, a template was needed to define how each individual item in the list should be displayed. This template was created using HTML and was defined within a special

element with a data-win-control attribute set to WinJS.Binding.Template. Within the template, you could use a data-win-bind attribute to bind the properties of your data objects to the HTML elements. For example, you could bind the src attribute of an tag to a property on your data object that contained the URL of an image.

When the ListView was rendered, it would automatically use the template to create the HTML for each item in the data list, performing the data binding as it went. The 70-481 Exam required a deep understanding of this data binding model. It also covered techniques for formatting the data for display, such as using converters to format dates or currency values according to the user's locale.

UI Design Concepts from the 70-481 Exam

To succeed in the UI design portion of the 70-481 Exam, a candidate needed to synthesize their knowledge of HTML, CSS, and WinJS into a coherent set of design and implementation strategies. It was about seeing the bigger picture of how to build a complete and well-structured user interface that was both functional and aesthetically pleasing.

One key concept was the idea of a component-based architecture. A complex UI should be broken down into smaller, reusable components. In the context of the 70-481 Exam, this was achieved through the use of PageControl objects for the main pages and custom controls for smaller, reusable UI elements. This approach makes the application easier to develop, test, and maintain.

Another core concept was the separation of concerns. The structure of the UI should be defined in HTML, the presentation and styling in CSS, and the behavior and logic in JavaScript. The 70-481 Exam required developers to follow this best practice. For example, you should avoid manipulating CSS styles directly from your JavaScript code whenever possible. Instead, you should define your styles in CSS classes and then use JavaScript to add or remove those classes from the HTML elements.

Finally, a key principle was to always design for an adaptive experience. From the very beginning of the design process, a developer needed to be thinking about how the UI would look and function in different view states and on different devices. This meant using fluid layout techniques, testing with different screen sizes, and using media queries to tailor the experience. A developer who could demonstrate this holistic and principled approach to UI design was well-prepared for the challenges of the 70-481 Exam.

Mastering JavaScript Fundamentals

While HTML and CSS were used to create the structure and appearance of a Windows Store app, JavaScript was the exclusive language for writing all the application's logic. Therefore, a deep and thorough mastery of JavaScript fundamentals was the most critical prerequisite for the 70-481 Exam. This went far beyond basic scripting and required a professional-level understanding of the language's features, syntax, and core concepts. A candidate could not succeed on the exam without being a proficient JavaScript developer.

The exam expected a strong command of JavaScript's core data types, such as strings, numbers, booleans, objects, and arrays. It also required fluency in working with operators, control structures (like if-else statements and loops), and functions. A key aspect was understanding the concept of scope in JavaScript, including the difference between global and local scope, and how closures work. These are fundamental building blocks for writing well-structured and bug-free code.

Object-oriented programming (OOP) concepts in JavaScript were also a key topic. While JavaScript is a prototype-based language, the exam required an understanding of how to use it to create objects, define methods, and implement concepts like encapsulation and inheritance. This included knowing how to use constructor functions and the prototype property to create reusable and maintainable code.

Furthermore, the 70-481 Exam focused on the modern features of the language. This included understanding how to work with the Document Object Model (DOM) to programmatically manipulate the HTML elements of the user interface. It also involved a deep understanding of JavaScript's event-driven programming model, which is the foundation for creating interactive applications. A solid grasp of these JavaScript fundamentals was non-negotiable for any developer attempting this certification.

Managing Program Flow and Events

A core part of developing the logic for any interactive application is managing the program flow and responding to user events. The 70-481 Exam placed a strong emphasis on a developer's ability to use JavaScript to create a responsive and interactive user experience. This meant being an expert in JavaScript's event-driven programming model. In this model, the application spends most of its time waiting for events to occur and then executes specific code in response to those events.

The most common events are user-initiated, such as a user clicking a button, tapping an item in a list, or typing text into a search box. A developer needed to know how to attach event listeners to the HTML elements to handle these events. This involved using the addEventListener method to register a callback function that would be executed when the event occurred. The exam tested the ability to correctly wire up these event handlers to the UI.

Beyond user events, the application also needed to respond to system and application lifecycle events. For example, the application would fire events when it was being launched, suspended, or resumed by the operating system. A developer was responsible for writing the event handlers for these lifecycle events to save and restore the application's state, ensuring a seamless user experience.

The WinJS library, which was central to the 70-481 Exam, also had its own set of custom events for its UI controls. For example, a ListView control would fire an iteminvoked event when the user tapped on an item. A developer needed to know how to subscribe to these control-specific events to implement the application's logic. A deep understanding of this event-driven model was crucial for building a functional Windows Store app.

The Asynchronous Nature of Modern Apps

One of the most important and often challenging concepts for developers preparing for the 70-481 Exam was asynchronous programming in JavaScript. In order to keep the user interface fast and fluid, any long-running operation, such as reading a large file from disk or fetching data from a network service, must be performed asynchronously. This means that the operation is started, but the application does not wait for it to complete. The UI thread remains free to respond to user input.

If a long-running operation were performed synchronously on the main UI thread, the entire application would freeze until the operation was finished. This would create a terrible user experience, making the app feel sluggish and unresponsive. The Windows Store app model strictly enforced this asynchronous pattern for almost all of its platform APIs. Any call that could potentially take a long time to complete was designed to be asynchronous.

This had a profound impact on how the application logic was written. Instead of a simple, linear sequence of commands, the code had to be structured to handle the results of these asynchronous operations when they eventually completed. The developer would initiate the operation and provide a callback function that would be executed once the operation finished and the result was available.

Mastering this asynchronous mindset was a key differentiator for successful candidates of the 70-481 Exam. It required a shift in thinking from traditional, synchronous programming models. A developer needed to be able to reason about the flow of an application where multiple operations could be happening in the background concurrently. This skill is even more critical today, as asynchronous programming is at the heart of all modern web and application development.

Working with Promises in JavaScript

To manage the complexity of asynchronous programming, the Windows Library for JavaScript (WinJS) made extensive use of a pattern known as Promises. A deep understanding of how to work with Promises was an essential skill for the 70-481 Exam. A Promise is an object that represents the eventual result of an asynchronous operation. It is a placeholder for a value that is not yet known.

An asynchronous function in the WinRT or WinJS APIs did not return the final result directly. Instead, it immediately returned a Promise object. This Promise object could be in one of three states: pending (the operation is still in progress), fulfilled (the operation completed successfully and has a result), or rejected (the operation failed and has an error).

To get the result of the operation, a developer would use the .then() method of the Promise object. The .then() method takes two arguments: a function to be executed if the promise is fulfilled (the success callback), and an optional function to be executed if the promise is rejected (the error callback). This provided a much cleaner and more structured way to handle asynchronous code compared to traditional nested callbacks.

Promises could also be chained together. The .then() method itself returns a new Promise, which allows you to create a sequence of asynchronous operations that execute one after another in a readable, linear fashion. This chaining capability was a powerful feature for managing complex workflows. A strong, practical ability to consume and chain Promises was a core JavaScript skill tested by the 70-481 Exam and is a fundamental pattern in modern JavaScript today.

Accessing Data (Local, Remote, and Files)

Virtually every application needs to work with data. The 70-481 Exam required a developer to be proficient in accessing data from a variety of sources using JavaScript. This included working with data that was stored remotely on a web server, data that was stored locally within the application's storage, and data from the user's local files and libraries. The methods for accessing each of these sources were different, and a developer needed to know the appropriate APIs for each scenario.

For accessing remote data from a web service or API, the primary tool was the WinJS.xhr function. This was a wrapper around the standard XMLHttpRequest object that was designed to work seamlessly with the WinJS Promise-based asynchronous model. A developer needed to know how to use WinJS.xhr to make HTTP requests (like GET and POST) to a remote endpoint, handle the response (often in JSON format), and manage any errors that might occur.

For storing data locally within the application, Windows Store apps had a dedicated, sandboxed storage area. A developer could use the Windows.Storage.ApplicationData APIs to store settings and small amounts of data in the app's local or roaming data folders. This was useful for saving user preferences or the application's state. For larger amounts of structured local data, technologies like IndexedDB could be used.

Finally, to access the user's own files, such as their documents or pictures, the application had to use the Windows.Storage.Pickers APIs. These APIs would show a system-provided file picker dialog that allowed the user to explicitly select a file or folder for the application to access. This was a key security feature of the platform. A deep knowledge of these different data access methods was a critical part of the 70-481 Exam curriculum.

Managing Application State and Lifecycle

As discussed in Part 1, Windows Store apps had a unique and managed application lifecycle. A developer preparing for the 70-481 Exam needed to have a deep, practical understanding of this lifecycle and know how to write the JavaScript code to manage it correctly. The application could be in various states, such as not running, running, suspended, or terminated, and the developer was responsible for handling the transitions between these states gracefully.

The main entry point for managing the lifecycle was the activated event. This event would fire whenever the application was launched or activated by the user. The event handler for this event was responsible for setting up the initial UI of the application. The event arguments would provide information about why the app was activated (e.g., a fresh launch, or activated to handle a search request).

One of the most important lifecycle events was the suspending event. This event would fire just before the operating system was about to suspend the application to save system resources. This was the developer's last chance to save any important application state. This could include things like the user's current position in a document, the contents of a form they were filling out, or any other data needed to restore the user's session exactly as it was.

If the user returned to the app shortly after it was suspended, the app would be resumed, and its state in memory would be preserved. However, if the system needed to reclaim memory, it might terminate a suspended app. In this case, when the user launched the app again, the developer would need to check if there was any saved state from the previous session and use that data to restore the application to its last known state. This save/restore process was a fundamental skill for the 70-481 Exam.

Implementing Background Tasks

To provide a rich and engaging user experience, Windows Store apps needed the ability to perform some work even when they were not running in the foreground. This was achieved through the use of Background Tasks. A background task is a small piece of code that can be scheduled to run periodically or in response to a specific system trigger, such as a change in the internet connection status or the arrival of a push notification. A solid understanding of how to implement background tasks was a key advanced topic for the 70-481 Exam.

Background tasks ran in a separate process from the main application and had limited resources in terms of CPU time and memory. This was a deliberate design choice to preserve the battery life and performance of the device. A developer had to create a separate JavaScript file for the background task's logic. This file would contain a run method that would be executed when the task was triggered.

Before a background task could be used, it had to be registered by the main application. This involved specifying the JavaScript file for the task, the trigger that should activate it, and any conditions that must be met for it to run (e.g., the device must have an internet connection). The application also had to declare its intention to use background tasks in its manifest file.

Common use cases for background tasks included periodically fetching new data from a web service to update the app's live tile, synchronizing data in the background, or playing audio while the app was not in the foreground. The ability to use these background tasks to create a more dynamic and connected application experience was a key skill for a developer targeting the 70-481 Exam.

JavaScript Development Principles from the 70-481 Exam

To succeed in the JavaScript development portion of the 70-481 Exam, a candidate needed to demonstrate a commitment to modern, professional development principles. It was not enough to just write code that worked; the code also had to be well-structured, maintainable, and efficient. Several key principles were emphasized throughout the exam's objectives.

The first principle was modularity and separation of concerns. A complex application should be broken down into smaller, more manageable JavaScript files, each with a specific responsibility. For example, you might have one file for data access logic, another for the logic of a specific page, and another for utility functions. This makes the code easier to read, test, and debug. The use of namespaces was also encouraged to avoid polluting the global scope.

Another key principle was to write efficient and performant code. In a touch-based UI, responsiveness is paramount. This meant avoiding long-running synchronous operations on the UI thread, as discussed earlier. It also involved being mindful of memory usage and using efficient algorithms, especially when dealing with large collections of data. For example, a developer was expected to know how to use the virtualization features of the WinJS ListView to display large lists without performance degradation.

Finally, the principle of writing secure code was important. While the platform provided a secure sandbox, the developer was still responsible for writing code that was not vulnerable to common web-based attacks, especially if the app displayed content from the web. This included practices like validating user input and properly sanitizing any external data before displaying it in the UI. A developer who could demonstrate these professional practices was well-prepared for the 70-481 Exam.

Conclusion

A core skill that differentiated a Windows Store app from a standard website, and a major focus of the 70-481 Exam, was the ability to interact with the underlying operating system. This was made possible through the Windows Runtime, or WinRT. WinRT was a new set of APIs introduced with Windows 8 that exposed a vast range of native platform capabilities directly to application developers. For those taking the 70-481 Exam, the key was that these native APIs were made accessible to JavaScript.

This was achieved through a mechanism called language projection. The WinRT APIs were built on a common foundation that allowed them to be "projected" into different programming languages, including C++, C#, and, most importantly for this exam, JavaScript. This meant that a JavaScript developer could make calls to the WinRT to perform tasks that were traditionally reserved for native code, such as accessing the file system or using the device's camera.

The WinRT APIs were organized into a hierarchical structure of namespaces, much like the .NET Framework. For example, all the APIs for working with storage were located in the Windows.Storage namespace, while the APIs for networking were in the Windows.Networking namespace. A developer needed to be familiar with the key namespaces and the classes and methods they contained to perform various platform integration tasks.

Virtually all of the WinRT APIs that involved I/O or any potentially long-running operation were designed to be asynchronous and returned Promise objects. This enforced the "fast and fluid" design principle of the platform. A deep, practical understanding of how to call these WinRT APIs from JavaScript and how to handle the asynchronous results using Promises was an absolute requirement for the platform integration section of the 70-481 Exam.

Go to testing centre with ease on our mind when you use Microsoft 70-481 vce exam dumps, practice test questions and answers. Microsoft 70-481 Essentials of Developing Windows Store Apps Using HTML5 and JavaScript certification practice test questions and answers, study guide, exam dumps and video training course in vce format to help you study with ease. Prepare with confidence and study using Microsoft 70-481 exam dumps & practice test questions and answers vce from ExamCollection.

How to open VCE Files

Use VCE Exam Simulator to open VCE files

Learn More Full Version

Top Microsoft Certifications

Top Microsoft Certification Exams

Site Search:

Pass Your Microsoft 70-481 Exam Easy!

A Foundational Guide to the Concepts of the 70-481 Exam

The Core Technologies: HTML5, CSS3, and JavaScript

Target Audience for the 70-481 Exam Concepts

Key Skill Areas Measured by the Exam

The Windows Store App Paradigm

Why Web Development Skills Remain Crucial

From Windows 8 to Modern Development

A Roadmap for Exploring the 70-481 Exam Topics

Principles of Modern UI/UX Design

Structuring an App with HTML5