Category Archives: Uncategorized

Creating Data-Driven Windows 8 Apps from Microsoft’s Grid Template using REST APIs for Designers

By Don Burnett Microsoft Blend MVP (2012-2013)

Part One: Getting Started with Live Data In your App from and existing REST style Web Service…

One of the things that has been difficult with Windows 8 Apps for designers is getting at data to model it and use it in an App. With Silverlight and WPF Microsoft’s Blend has provided us with a bunch of really great tools to help us model data in an app and done the heavy lifting to make it easy to use that data directly when designing the user experience. Unfortunately when Blend was refocused to be a part of the Visual Studio family of products, the same care was not given to make data available to the “app designer” as part of a Windows Store App.

We can still work with Data but a lot of the heavy lifting has to be done by ourselves. Many apps today bring in data from an outside source, and really just consume data from some other source out there. This article will walk through the process from the designer perspective about getting data into an “app”. In this article we will walk through the process of replacing the data model in one of Microsoft’s sample GRID templates with Data from a REST data source.

In the past in as a WPF, Silverlight, or Windows Phone app designer we could just do the following steps in Blend to model our data.

  1. From The Data Tab in Blend: select Import Sample Data from XML

  2. Add the URL to our REST data API query.

    In this case I am going to look at some transit data in European SIRI format from a REST api. I just name my data source and in the XML file path I just place the URL to the data source query..

    http://api.SIRIDATA.org/rest/stopmonitoring/?monitoringref=2903

    If we looked at this data by pasting the URL in a WEB browser the results returned would look like this (an XML document)

  3. After doing this Blend creates a schema and gives me a look at the fields and I can drag and drop live data onto my design surface from this panel. The image below shows us that panel with the schema for the data source along with data types that can be adjusted based on the types of data.

This certainly made designing from data and consuming data from an API easier. You could then just drag and drop anything in that panel to data bind live data right into your interface. In fact it was pure heaven for designers because we could see changes in real-time. With Windows 8 much of this has changed for Windows Store apps. Designers no longer have this power in Blend for Windows Apps due to a number of refactoring’s of the .NET framework (aka WinRT) to support as the framework was optimized for more asynchronous delivery models and targeting different devices out there, including ARM tablets and others. However ALL is *NOT* lost and hopefully we will be able to step through this new process for you.

So how can we address this in Windows 8 as a Windows Store App? There are just a few more steps necessary. Let’s start by using one of the Grid Templates. Normally I would do this in Blend first, but in this release with the new manifests and settings I am going to do this part in Visual Studio and create a GRID template app called TransitApp.. I will assume you have already created this for this walk-thru..

Our process will include:

  1. Create a portable class library so that we can build assemblies that work on all Microsoft platforms, thus reducing the amount of work required to move the data layer between potential platforms that we may wish to create versions of our app for.

Platform

.NET for Windows Store apps

.NET Framework 4.0 through 4.5

Silverlight 4 and 5

Windows Phone 7.0 through 8.0

Windows Azure

X-Box

 

  1. Make Calls to a REST Service with System.Net.Http.HttpClient
  2. Replace the sample data source and make Asynchronous Calls to it
  3. Add items to our master-detail Windows Store Grid Template

Step One: Creating the Portable Class Library for our Data Layer

In the past, to share code between a Web service and a WPF application, we might create a Class Library project. To do this with Windows Store apps we must create a portable class library. This will allow us to build assemblies that work across the spectrum of Windows projects and share entities between a REST service and the Windows Store app (.NET for Windows Store apps) without code duplication on either client or server platforms. At the time of this writing, we are required to use Visual Studio 2012. So let’s walk through this process now. This assumes you have already created your own Windows Store App from the Grid Template.

In a VS 2012 Windows Store App Solution (XAML)

  • Select File.. Add ..New Project…
  • Select Templates ..Visual C# in the left pane.Select Portable Class Library.


  • Enter your desired name for the library in the Name textbox. I’ll use TransitApp.Entities because both my app and a REST service will share the entities defined in this portable class library.
  • Click OK.. When the Add Portable Class Library dialog box appears select only the following target frameworks:
    • .NET Framework 4.5
    • .NET for Windows Store apps


  • Visual Studio will add the new TransitApp.Entities Portable Class Library to the solution.
  • To verify things are correct, go to and open References, there will be a reference to .NET Portable Subset.
  • Verify that the portable class library includes an initial class, Class1 which we will delete since it is auto-generated.
  • Delete Class1
  • Add a new interface, IEntity:

 
 

namespace TransitApp.Entities
{
public interface IEntity
{
string Id { get; set; }
}
}

 

  • Add a new class, Entity, that implements the previously created IEntity interface:
    {
    public class Entity : IEntity
    {
    public string Id { get; set; }
    }
    }

     

  • Add a new class, Item, that inherits from Entity:

 
 

namespace TransitApp.Entities
{
public class Item : Entity
{
public string Title { get; set; }
public string Subtitle { get; set; }
public string Description { get; set; }
public string Content { get; set; }
public string MainPage { get; set; }
}
}

 

  • Add a new class, Group, that inherits from Entity and groups items:

 
 

namespace TransitApp.Entities
{
using System.Collections.Generic;

public class Group : Entity
{
public string Title { get; set; }
public string Subtitle { get; set; }
public string Description { get; set; }
public string MainPage { get; set; }
public IEnumerable<Item> Items { get; set; }
}
}

  • That’s all we have to do and we are ready to go with our new portable class library
  • Next Go back to the TransitApp project/solution that generates our Windows Store app
  • Right click on References in Solution Explorer
  • Select Add Reference…
  • Inside the Reference Manager, Click on Solution..Projects in the left pane, check TransitApp.Entities and click OK. This allows the Windows Store app to use all of the entities defined in our portable class library.

 

Step Two: Calling our REST Service with System.Net.Http.HttpClient

Next we will consume our REST service in our Grid Template based transit app by using the new asynchronous methods provided by the new System.Net.Http.HttpClient.

Go to the TransitApp project/solution

Add a new Services folder.


Add a new interface, IGroupService, within the Services folder. The following is the code for IGroupService:

    namespace TransitApp.Services

{
using System.Collections.Generic;
using System.Threading.Tasks;

    //// TransitApp.Entities (Portable Class Library)
using Entities;

    public interface IGroupService
{
Task<IEnumerable<Group>> GetAll();
}
}


Create a subfolder named Implementation within the Services folder.

Add a new class, GroupService, within Services\Implementation.

Implement the previously created interface:


namespace TransitApp.Services.Implementation
{
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;

    //// TransitApp.Entities (Portable Class Library)
using Entities;

    public class GroupService : IGroupService
{
private const string RestServiceUrl = “http://localhost:46037/api/&#8221;;

    public async Task<IEnumerable<Group>> GetAll()
{
var client = new HttpClient
{
BaseAddress = new Uri(RestServiceUrl)
};

//// Add and support a header for JSON
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(“application/json”));

    //// Retrieve groups and items

var response = await client.GetAsync(“groups”);

    //// Exception throw if problems
response.EnsureSuccessStatusCode();

    
//// In case you need date and time properties

const string dateTimeFormat = “yyyy-MM-ddTHH:mm:ss.fffffffZ”;
var jsonSerializerSettings = new DataContractJsonSerializerSettings
{
DateTimeFormat = new DateTimeFormat(dateTimeFormat)
};

    var jsonSerializer = new DataContractJsonSerializer(
typeof(Group[]),
jsonSerializerSettings);

    var stream = await response.Content.ReadAsStreamAsync();
return (Group[]) jsonSerializer.ReadObject(stream);
}
}
}

The GroupService class has a GetAll method that uses the async modifier to return a Task<IEnumerable<Group>>. This method is called with the await keyword. You will be able to retrieve an IEnumerable<Group> without having to worry about a Task wrapper.

The GetAll method does the following:

Creates a new instance of the System.Net.Http.HttpClient class and sets its base address to our REST service URL.

var client = new HttpClient
{
BaseAddress = new Uri(RestServiceUrl)
};

Adds and accepts a header for JSON for the HttpClient instance.

    
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(“application/json”));

Make the REST call to GET api/groups with an asynchronous execution by using the HttpClient.GetAsync method. The method returns a Task<HttpResponseMessage> that the await keyword develops into an HttpResponseMessage.

var response = await client.GetAsync(“groups”);

Call the EnsureSuccessStatusCode for the HttpResponseMessage instance. This method throws an exception if something goes wrong.

response.EnsureSuccessStatusCode();

Creates a new instance of DataContractJsonSerializerSettings and sets a value for the DateTimeFormat property. This isn’t all there is to deserializing JSON with REST calls in Windows Store apps but it will get you started.


const string dateTimeFormat = “yyyy-MM-ddTHH:mm:ss.fffffffZ”;
var jsonSerializerSettings = new DataContractJsonSerializerSettings
{
DateTimeFormat = new DateTimeFormat(dateTimeFormat)
};


Create a new DataContractJsonSerializer instance specifiying and array of Group as a type and the previously explained settings.


var jsonSerializer = new DataContractJsonSerializer( typeof(Group[]), jsonSerializerSettings);

    

Call the ReadAsStreamAsync method for the Content property of the response that is an instance of HttpContent. The method returns Task<System.IO.Stream>. The call is made with an asynchronous execution by using the await keyword that creates the response into a System.IO.Stream instance.


var stream = await response.Content.ReadAsStreamAsync();

The code returns the results of the call to the ReadObject for the DataContractJSonSerializer instance that receives the previously read System.IO.Stream as a parameter. The code returns an array of Group (Group[]).

return (Group[]) jsonSerializer.ReadObject(stream);


Note: It is necessary to make sure that the App manifest provides outbond access to the Internet to consume the REST service with HttpClient.

In the TransitApp Visual Studio project/solution:

Double click on Package.appxmanifest and then select the Capabilities page, and make sure Internet (Client) is checked.

 

Step Three: Replacing the sample data source included in our Grid app template


Next we are go to replace the sample data source included in the Grid app template with the results of calling our previously created GetAll method to retrieve all the groups and their items from the REST service.


Process:

 

Remove all the code in the SampleDataSource constructor from the TransitApp project Template. We absolutely have to do this because the constructor was adding the sample groups and items.

Add a new static asynchronous method to the SampleDataSource class (RefreshDataSource):

public static async Task RefreshDataSource()
{
var groupService = new GroupService();
var allGroups = await groupService.GetAll();
foreach (var group in allGroups)
{
var sampleDataGroup = new SampleDataGroup(
group.Id,
group.Title,
group.Subtitle,
“Assets/LightGray.png”,
group.Description);

_sampleDataSource.AllGroups.Add(sampleDataGroup);

if (group.Items != null)
{
foreach (var item in group.Items)
{
sampleDataGroup.Items.Add(new SampleDataItem(
item.Id,
item.Title,
item.Subtitle,
“Assets/DarkGray.png”,
item.Description,
item.Content,
sampleDataGroup));
}
}
}
}

Go to App class (App.xaml.cs) and change the code for the OnLaunched event handler so that it calls the previously created SampleDataSource.RefreshDataSource with an asynchronous execution when the app’s previous state is ApplicationExecutionState.NotRunning.

protected override async void OnLaunched(LaunchActivatedEventArgs args)
{
Frame rootFrame = Window.Current.Content as Frame;

    // Don’t initialization if content exists,
// Make sure window is active

if (rootFrame == null)
{
// Create a Frame to act as the navigation context, and navigate to first page
rootFrame = new Frame();
//Associate the frame with a SuspensionManager key
SuspensionManager.RegisterFrame(rootFrame, “AppFrame”);
    if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
// Restore the saved session state when appropriate
try
{
await SuspensionManager.RestoreAsync();
}
catch (SuspensionManagerException)
{
//Something went wrong restoring state.
//
}
}
else if (args.PreviousExecutionState == ApplicationExecutionState.NotRunning)
{
//// Retrieve all the groups by making a call to the REST service
try
{
await Data.SampleDataSource.RefreshDataSource();
}
catch (Exception ex)
{
////Something went wrong write your code here…
}
}
    // Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn’t restored navigate to the first page,
// configure the new page by passing information as a navigation
// parameter
if (!rootFrame.Navigate(typeof(GroupedItemsPage), “AllGroups”))
{
throw new Exception(“Failed to create initial page”);
}
}
// Ensure the current window is active
Window.Current.Activate();
}

 

 

To Be Continued..


 

Creating a Sharing Contract for Windows 8 & RT Apps

By Don Burnett
Expression Blend MVP

The coolest new feature that I really love about Windows 8 and Windows RT is that they now have a new universal sharing interface. If you swipe inward on a touch screen from the right side of the screen (or mouse to the top right pixel) you will get presented with a new menu of options called “Charms” one of these is a sharing button. If you have a new surface or brand new Windows 8 keyboard from Microsoft you will notice this is a button in the new layout as well.

image

When you select the charms button a new side panel will appear with different apps that will let you share to and from. If you are trying to share from a desktop app I recommend an app on the Windows store called “Clipboard” which will let you take stuff easily through the new sharing interface should your app not be clipboard enabled with the desktop.

image

Implementing a Sharing Contract in Our App

The first thing we will need to do is to wire up the DataTransferManager into the MainPage of our app code..

Using Windows.ApplicationModel.DataTransfer;

Next we create an event handler for it in code

DataTransferManager manager = DataTransferManager.GetForCurrentView();
manager.DataRequested += manager_DataRequested;

Next we create some simple event handler code so when the share charm is invoked to the user the event is passed to our page..

void manager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
DataRequest request = args.Request;
request.Data.Properties.Title = "Handy Dandy Share contract";
request.Data.Properties.Description = "Share some text";
request.Data.SetText("Sharing is Caring..");
}

The framework decides on the correct share client based on the format of the content that we plan to share.. The example above is text, but you could easily wrap in a share to Facebook or a share to twitter by simply adding code for it to your app..

image

If my app were using HTML for instance and I was sharing some HTML info that I wanted to share over mail it might look like this..

void manager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
  DataRequest request = args.Request;
  request.Data.Properties.Title = string.Format("Sharing Is Caring - {0}", CurrentPortTitle);
  request.Data.Properties.Description = "Sharing this info";
  TilePort sharePort = TilesQueue.ToArray().FirstOrDefault(p => p.ID.Equals(CurrentPortID));
  string htmlMail = BuildHtml(CurrentPort);
  string htmlFormat = HtmlFormatHelper.CreateHtmlFormat(htmlMail);
  request.Data.SetHtmlFormat(htmlFormat);
}

Types of data you are allowed to share from your app..

  • Plain text
  • Uniform Resource Identifiers (URIs)
  • HTML
  • Formatted text
  • Bitmaps
  • Files
  • Developer-defined data

The core of any sharing operation is the DataPackage object. This object contains the data the user wants to share. A DataPackage can contain a delegate. A delegate is a function that is called when the receiving app requests data. You should use a delegate any time that the data a user wants to share is resource-intensive. A delegate can help your app share data more efficiently.

The example above only is a simple text sharing contract..

To share content such as images or files, we will need to add the following namespaces as well. Here’s a list of the namespaces necessary..

  • Windows.Storage. Needed for working with StorageFile and other objects.
  • Windows.Storage.Pickers. Used to open the file picker so users can select images and files.
  • Windows.Storage.Streams. Often used when sharing images, files, and custom-formatted data.
  • Windows.Graphics.Imaging. Useful if you need to modify images before sharing them.

Sharing a hyperlink

private void RegisterForShare()

{

// create DataTransferManager object

DataTransferManager dataTransferManager = DataTransferManager.GetForCurrentView();


// create event handler

dataTransferManager.DataRequested += new TypedEventHandler<DataTransferManager, DataRequestedEventArgs>(this.ShareLinkHandler);

}

private void ShareLinkHandler(DataTransferManager sender, DataRequestedEventArgs e)

{

  // Set title and Description Properties

DataRequest request = e.Request; request.Data.Properties.Title = “Share My Cool Link”; request.Data.Properties.Description = “Add a link (URI) to share.”;

// To add the link, use the SetUri method.

request.Data.SetUri(new Uri(https://blendersuxblog.wordpress.com));

}

Share an Image

Here’s an example to share an image..

private void RegisterForShare()

{
DataTransferManager dataTransferManager = DataTransferManager.GetForCurrentView();
dataTransferManager.DataRequested += new TypedEventHandler<DataTransferManager, DataRequestedEventArgs>(this.ShareImageHandler);
}

private async void ShareImageHandler(DataTransferManager sender, DataRequestedEventArgs e)

{ DataRequest request = e.Request; request.Data.Properties.Title = “Share My Graphic Image”; request.Data.Properties.Description = Image Sharing.”;

// Remember also when we start making async calls in the DataRequested event handler,
// we need to get the deferral before anything else..

DataRequestDeferral deferral = request.GetDeferral();

// Make sure we always call Complete on the deferral.

try
{
StorageFile thumbnailFile = await Package.Current.InstalledLocation.GetFileAsync(“Assets\\VNEXTLOGO.png”);

request.Data.Properties.Thumbnail = RandomAccessStreamReference.CreateFromFile(thumbnailFile);

StorageFile imageFile = await Package.Current.InstalledLocation.GetFileAsync(“Assets\\VNEXTLOGO.png”);
request.Data.SetBitmap(RandomAccessStreamReference.CreateFromFile(imageFile));
}

finally
{
    deferral.Complete();
}
}


Ford Focus Electric SmartPhone Integration

Engadget.com has a great report on SmartPhone Integration with the Ford Focus Electric..

Check out the report at:

http://www.engadget.com/2012/04/17/ford-focus-electric-test-drive-and-myford-mobile-hands-on-video/

Fun With Big Data Using the Microsoft “Data Explorer” Pt. 1

Microsoft has released a new Community Tech Preview of a new tool for working with “Big Data”.  Just what is Big Data ? Well simply it’s compiled statistical information that is out and available in on the internet in the computing cloud.. There is a vast amount of data available today and data is now being collected and stored at a rate never seen before. Much, if not most, of this data however is locked into specific applications or formats and difficult to access or to integrate into new uses.  “Data Explorer as a tool allows you to start exploring these sources

Data comes from a number of different sources out there including:

SQL databases, Web Page Content (including RSS feeds), XML formatted metadata sources such as OData feeds, SharePoint Repositories and others..

image

Windows Azure Data Market Place

The Windows Azure™ Marketplace is an online market buying, and selling finished Software as a Service (SaaS) applications and premium datasets. The Windows Azure Marketplace helps connect companies seeking innovative cloud based solutions with partners who have developed solutions that are ready to use.

SharePoint

Every Microsoft SharePoint list and library in a site has a corresponding data source connection in the Data Source Library. To add a SharePoint list or library to the Data Source Library, you can either create a new list or library or create a new connection to an existing list or library.

Any SharePoint lists or libraries that you create will also automatically have a corresponding data source connection in the Data Source Library.

Odata

The Open Data Protocol (OData) is a Web protocol for querying and updating data that provides a way to unlock your data and free it from silos that exist in applications today. OData does this by applying and building upon Web technologies such as HTTP, Atom Publishing Protocol (AtomPub) and JSON to provide access to information from a variety of applications, services, and stores. The protocol emerged from experiences implementing AtomPub clients and servers in a variety of products over the past several years. OData is being used to expose and access information from a variety of sources including, but not limited to, relational databases, file systems, content management systems and traditional Web sites.

SQL Databases

SQL was initially developed at IBM by Donald D. Chamberlin and Raymond F. Boyce in the early 1970s.   Structured Query Language) is a programming language designed for managing data in relational database management systems (RDBMS). SQL databases have been the standard since they were invented.

Connection Walk-Thru

Let’s walk through a short sample of connecting to a data source. I will choose Netflix’s OData as a source, to make this example fun.

image

First press plus: at the top menu to create a new mash-up..

in the dialog box we will type in the name for our new mashup  and name it “NetflixMashup”

image

next we will add our data from the Netflix OData server.. Clicking on the “Data Feed” icon will allow us to create our new data source..

image

Our next step will be to add our NetFlix Feed URL

For this example I will use one of the feeds that are available as a top level resource, in this case the Netflix Catalog Titles http://odata.netflix.com/Catalog/

Next it will ask us how to connect to the feed.. We enter the feed URL

image

Add the URL to the mashup workflow wizard and click ‘Done’

Authentication Notes:

If the feed requires windows authentication, a name and password, or an OData feed key you will have an opportunity to enter it to set feed security options. Since the listing we are connecting to is public and has none of these we will press ‘continue’ to connect with it, leaving the ‘Use anonymous access’ option making sure that radio button is selected.

When the Data Feed is successfully parsed we will see the feed with the formatting schema.. then we can click ‘Done’ to continue.

Removing fields we won’t use

When the fields have been parsed on the data field we can  right click on the fields and select “remove fields”  on all of the the ones we won’t use and then click the ‘done’ button.

Next we are going to select the fields we are going to use to gather the data we are using.. For this demonstration I am going to just select ‘Titles’.

Next Steps

Now we can click on “more tools..

image

This will expose more menus..

image

Click or Double click on the Select Fields Icon/Toolbar and the screen should change..

image

Check the checkboxes for fields to include (I am selecting all of them) and click ‘Done’.

To Be Continued…

In part two we will output to a table and look at some results and then finish up with a look at an example using the Azure Data Marketplace with data.gov and do some statistical analysis..

More Information:

For another look at using this product check out Lynn Langit’s  Blog post on using Data Explorer on her blog..

http://lynnlangit.wordpress.com/2011/12/10/exploring-microsoft-data-explorer/

Mobile Technology Association of Michigan Membership

A group we love..   http://www.gomobilemichigan.org/  Mobile Technology Association of Michigan, MTAM is now accepting members and providing great benefits to those members!

image

Win 20 Grand Creating Apps for Entrepreneurs

Apps for Entreprenuers from iStrategyLabs on Vimeo.

Create apps to help small businesses and entrepreneurs navigate the Federal Government more effectively.. http://entrepreneurs.challenge.gov/

 

Official Rules from Challenge.gov

http://entrepreneurs.challenge.gov/rules

Apps for Entrepreneurs
Official Rules
Background

For most entrepreneurs and small businesses, the Federal government has useful programs and services, but it can be hard to identify, engage and navigate Federal websites. Often, small businesses do not know that the Federal government already offers a program that they would find useful. Entrepreneurs and small businesses need better tools to navigate the Federal government’s vast resources – including programs, services, and procurement opportunities.

The Competition Goals

The Apps for Entrepreneurs Competition (the “Competition”) is an initiative of the U.S. Small Business Administration (SBA) to help make Federal government programs and information more useful to small businesses. The Competition will provide recognition to individuals or teams of individuals for developing innovative applications designed for the Web, a personal computer, a mobile handheld device, console, or any platform broadly accessible on the open internet that utilize data which is freely available on Federal government websites.

The Apps submitted for this Competition must use data from at least one of the following sources: Small Business Administration http://www.sba.gov/api; Small Business Innovation Research Program http://www.sbir.gov/apis; Green Government Opportunities for Small Business http://green.sba.gov/apis or Data.gov www.data.gov.

Important Dates

Submission Period: 1:00 am EST, November 5, 2011 to 11:00 pm ET, November 20, 2011

Judging Period: November 21-22, 2011

Winners Announced: November 23, 2011

How to Enter

Interested persons should read the official rules before entering the Competition. All Contestants must submit their Apps through the Challenge.gov portal. Please note, in order to submit an App, Contestants will first need to register and create an account with Challenge.gov. Contestants will:

  1. Prior to submitting an App, register with www.challenge.gov. Registration is free
  2. From the Competition webpage on Challenge.gov http:// entrepreneurs.challenge.gov, use the “Enter a Submission” tab to submit a description of the app, outline system requirements to run the app and provide a link to a fully functioning app hosted outside of Challenge.gov. Once an App is submitted, the Contestant cannot make any changes or alterations to any part of the Submission.
  3. After submission, all apps will be screened by SBA for malicious code or other security issues.
  4. Screened submissions will be posted on the Challenge.gov Competition webpage on a rolling basis. Apps failing to meet Submission Requirements or other Submission screenings will be deemed ineligible to win a prize. Posting an app to the Competition website does not constitute SBA’s final determination of Contestant or the app’s eligibility.
Prizes

Seven (7) prizes are available:

Winner Quantity

1st Place: Gift Card ($5,000 value) 1

2nd Place: Gift Card ($3,000 value) 3

3rd Place: Gift Card ($2,000 value) 3

The winners of these prizes (collectively, “Winners”) will be announced on November 23, 2011. Only one prize will be awarded for each winning submission, regardless of the number of Contestants that created on the winning app. SBA reserves the right to substitute prizes of similar value without notice.

Judging

Judging Panels

Prior to judging, all submitted apps will be screened for Contestant eligibility, completeness of submission and malicious code.

The members of the Judging panel will be selected by SBA at its sole discretion and will be comprised of up to ten technology, small business, and entrepreneurship experts from both the public and private sectors. Judges will be screened by SBA to ensure he/she does not: (1) have personal or financial interest in any Contestant; or (2) have a familial relationship with a Contestant.

Judging Criteria

The Judging Panel will rate each Submission approved by the screening panel on the following criteria:

  1. Use of Required Data: Does the application use a combination of creative and relevant Federal data sets, including at least one data set from either http://www.sba.gov/apis; http://www.sbir.gov/apis; www.data.gov/apis or http://green.sba.gov/apis (25%)
  2. Technical Implementation: Is the application functional, well designed and simple to use? It is accessible to a wide range of users including those with disabilities? (25%);
  3. Mission and Impact: Does the application meet the goals of the Competition? Application will be rated on the strength of its potential to make Federal government programs and information more useful to small businesses (25%);
  4. Creativity: Is the application innovative, creative and interesting? (25%)

In the event of a tie, the SBA Administrator will select the winner.

Contestant Eligibility

The Competition is open to citizens or permanent residents of the United States who are at least eighteen (18) years old at the time of entry and teams of individuals where each individual is a U.S. citizen or permanent resident at least 18 years of age (collectively referred to as “Contestants”). Eligible Contestants may submit more than one app and/or participate on more than one team.

Any Submissions developed with Federal funding, either grant, contract or loan proceeds are not eligible to win. Federal employees and their immediate families, current SBA contractors and SBA grant recipients may enter the Competition but are not eligible to win. Immediate family members includes spouses, siblings, parents, children, grandparents, and grandchildren, whether as “in-laws”, or by current or past marriage, remarriage, adoption, co-habitation or other familial extension, and any other persons residing at the same household location, whether or not related.

Submission Requirements

In order for an entry to be eligible to win this Competition, the entry must meet the following requirements:

  1. General – Contestants must host their own app during the submission and judging process and ensure SBA has continued access to the app throughout the judging process.
  2. Availability – Submissions must be free to the public during the Competition and for at least one year after.
  3. Acceptable Platforms – The app must be designed for the Web, a personal computer, a mobile handheld device, console, or any platform broadly accessible on the open internet.
  4. Data – The app must utilize Federal government data and/or information available from any publically available Federal source, though they need not include all data fields or information available in a particular resource. Submissions must use at least one data set from any of the following resources: Small Business Administration http://www.sba.gov/apis; Small Business Innovation Research Program http://www.sbir.gov/apis; Green Government Opportunities for Small Business http://green.sba.gov/apis or Data.gov data.gov .
  5. Accessibility – The app must be accessible to a wide range of users, including users with disabilities (see Federal standards under Section 508 of the Rehabilitation Act http://www.section508.gov/index.cfm?fuseAction=stdsdoc ).
  6. Deadlines and Modifications – All Competition submissions must be submitted through the Challenge.gov portal by November 20, 2011 at 11:59 PM ET. Once an app is submitted through challenge.gov portal it must remain unchanged and unaltered until after the judging period.
  7. Intellectual Property – The Submission must not infringe any copyright or any other rights of any third party.
  8. No SBA logo – The app must not use SBA’s logo or official seal in the Submission, and must not claim SBA endorsement. The award of a prize in this Competition does not constitute an endorsement of a specific product by SBA or the Federal government.
  9. Functionality/Accuracy – A Submission may be disqualified if the application fails to function as expressed in the description provided by the Contestant, or if the application provides inaccurate information.
  10. Security – Submissions must be free of malware. Contestant agrees that SBA may screen the app to determine whether malware or other security threats may be present. SBA may disqualify the app if, in SBA’s judgment, the app may damage government or others’ equipment or operating environment.
  11. All Competition submissions must also adhere to the Challenge.gov Standards of Conduct (http://challenge.gov/terms#standards).
Copyright/Intellectual Property

By making a Submission under this Competition, each Contestant warrants that he or she is the sole author and owner of the Submission, that the Submission is wholly original with the Contestant (or is an improved version of an existing app that the Contestant has sufficient rights to use – including the substantial improvement of existing open-source apps), and that it does not infringe any copyright or any other rights of any third party. Each Contestant also warrants that the app is free of malware.

All tools submitted to the SBA Apps for Entrepreneurs Competition remain the intellectual property of the individuals or teams that developed them. By registering and entering a Submission, however, the Contestant agrees that SBA reserves an irrevocable, nonexclusive, royalty-free license to use, copy, distribute to the public, create derivative works from, and publicly display a Submission for a period of one year, starting on the date of the announcement of the Winners, and to authorize others, including the general public, to use the Submission without restriction on a royalty-free basis. The reservation of SBA rights to authorize use of the Submission by the public includes the Contestant’s assent to SBA’s release of the application under an open-source software license, if SBA so chooses. The Contestant agrees to execute a separate license with SBA, as appropriate, for such purposes.

Verification of Winners

Winners must continue to comply with all terms and conditions of these Official Rules, and winning is contingent upon fulfilling all requirements contained herein. The Winners will be notified by email by November 23, 2011. The Winner’s name(s) will also be posted on the Competition and/or SBA website. In the event that a potential Winner is disqualified for any reason, SBA may award the applicable recognition to an alternate Contestant.

Publicity

Participation in the Competition constitutes consent to SBA’s and its agents’ use of Competition winners’ name, likeness, photograph, voice, opinions, and/or hometown and state for promotional purposes in any media, worldwide, without further payment or consideration.

Liability and Insurance

The Contestant shall be liable for, and shall indemnify and hold harmless the Federal government against, all action or claims, including but not limited to those for loss of or damage to property (such as damage that may results from a virus, malware, etc. to SBA computer systems or those of the end-users of the software and/or applications), resulting from the fault, negligence, or wrongful act or omission of the Contestant.

Based on the subject matter of the Competition, the type of work that it will possibly require, and the likelihood of any claims for death, bodily injury, or property damage, or loss potentially resulting from contest participation, Contestants are not required to obtain liability insurance or demonstrate fiscal responsibility in order to participate in this Competition.

Applicable Law

This Competition is subject to all applicable Federal laws and regulations.

Disclaimer

SBA and its agents are not responsible for:

  1. Any incorrect or inaccurate information, whether caused by Contestants, printing errors, or by any of the equipment or programming associated with or utilized in the Challenge;
  2. Technical failure of any kind, including, but not limited to malfunctions, interruptions or disconnections in phone lines or network hardware or software;
  3. Unauthorized human intervention in any part of the entry process or the Competition;
  4. Technical or human error which may occur in the administration of the Competition or the processing of entries; or
  5. Any injury or damage to persons or property which may be caused, directly or indirectly, in whole or in part, from Contestant’s participation in the Competition or receipt, use or misuse of any prize.

If for any reason a Contestant’s entry is confirmed to have been erroneously deleted, lost, or otherwise destroyed or corrupted, Contestant’s sole remedy is another entry in the Competition.

General Conditions

SBA reserves the right at any time, for any reason, to cancel, suspend, and/or modify the Competition, or any part of it.

Participation constitutes each Contestant’s full and unconditional agreement to these Official Rules and administrative decisions which are final and binding in all matters related to the Competition. This contest notice is not an obligation of funds; the final award of prizes is contingent upon the availability of appropriations.

News from ACM Computers in Entertainment

image
Newton Lee, my friend and former colleague at Media Station Inc. sent this news to me:

 
11.16.11 Special News: ACM CiE, Disney Stories, and C5

Dear friends, colleagues, and supporters of ACM CiE,

I am pleased to share with you the exciting news:

1. We will be launching the new interactive ACM Computers in Entertainment website soon. Please look out for an email from ACM. Please send me your articles, interviews, blogs, and videos on the topics of games, art, music, TV, movies, society, education, et al.

image2. My new book Disney Stories: Getting to Digital (Springer 2012) is now available for pre-order on Amazon: http://www.amazon.com/exec/obidos/ASIN/1461421004/newtonlee-20/

imagePlease forward me the Amazon order confirmation and the info of the charity of your choice, 15% of my revenue will be donated to your charity!

3. Registration is now open for the 10th International Conference on Creating, Connecting and Collaborating through Computing (C5) to be held on 18-20 January 2012 at USC ICT. http://www.cm.is.ritsumei.ac.jp/c5-12/ It is an exciting conference you don’t want to miss.

Best regards,

Newton Lee

Founder and co-Editor-in-Chief

ACM Computers in Entertainment

read more at:

http://campaign.r20.constantcontact.com/render?llr=75onudcab&v=001iXIUy3Vz-XyFnkRtysZcLiqmLI_R7l9GzHrPRbgwulwww-O7sx0-K6O3HsAtvSuIMsBgvGZBLrpOIL_uQqLRbojKFng8MKIL6XeFGDtEI7Y%3D

Detroit ACM SIGGraph Meeting

The Art Institute of Michigan featuring local animators including Chris Carden and Dale Myers on November 16, 2011.

image

Dale Meyers Animation Studios

toonbots 2010 Demo Reel from Chris Carden on Vimeo.

 Register The event details are as follows

Organization:
The Art Institute of Michigan
Event :
Animation speakers & presentation
Date(s):
Nov 16 2011, 06:30 PM to 08:30 PM
Location:
28125 Cabot Drive Suite 120, Novi, MI 48377

Click Here For Detail:
Event Information

For further information contact:
Detroit ACM SIGGRAPH
Phone: 248.930.3911

Email: detsig@siggraph.org http://detroit.siggraph.org

Welcome to the BlendersUX Blog

Welcome to Blenders UXWelcome to the BlendersUX Blog.  We are a designer group for web and mobile app technologies across platforms..

We meet in Ann Arbor, Michigan at Washtenaw Community College.

You can catch us both on Facebook at:
http://www.facebook.com/?ref=logo#!/BlendersUX?sk=info

And on our Google Plus page at:
https://plus.google.com/u/0/?tab=mX#109534118191704266166/posts

Our next meeting is:      Tuesday, November 15 · 8:00pm – 9:00pm

Location:  Washtenaw Community College

Gunder Myron (Library) Building 1st Floor Lounge. Nearest 1C Stairs

Vending machines are available for refreshments.

November 15, 2011 Agenda

imageOur Meeting (tag-teamed with the Michigan Interactive Meeting) will feature Greg Good from PixelOasis.com who will walk us through creating a mobile application with Adobe Flash Builder.

We will further work on planning our inaugural meeting  in December at Washtenaw Community College. Which is tentatively scheduled to feature a local Apple iOS Design/Development Expert.