Pete Brown's Blog (POKE 53280,0)

TechEd India, the India developer communities, and the Taj Mahal

Pete Brown — Mon, 15 Apr 2013 05:07:41 GMT

In the second half of March, I traveled to India (Bangalore, Delhi, and Pune) to speak at TechEd India and TechDays Delhi about Windows 8 app development.

I flew from Dulles International in VA to Charles De Gaulle in France, where I met up with my colleague Nisha Singh, who had flown from Seattle. From there, we flew Air France to Bangalore for TechEd India Bangalore, then hopped a Jet Airways flight to New Delhi for TechDays Delhi. While there, I took a car to Agra over the weekend (more on that shortly). Then another Jet Airways flight from Delhi to Pune for TechEd India Pune. And finally, a short flight from Pune to Mumbai before the 16 1/2 hour flight from Mumbai to Newark NJ, and the prop plane from Newark to Dulles.

What I had expected

Before I went away to India, my only experience with developers in India was the lowest-price outsourcing companies I often had to clean up after as a consultant, the outsourced call center tech support folks I'll sell a kidney to avoid, and the numerous "send me the codes" emails I get. So, I had some pre-conceived notions as to what to expect from the developer community.

I'm happy to say I was completely wrong.

The developer community in India is strong, professional, and enthusiastic. The people I met at TechEd India were serious developers, building awesome apps and the usual bevvy of line of business apps internal to companies. The developer community in Pune, for example, is huge. The Pune .NET user group community (PUG) has membership in the mid 4 digits. Yep. That's pretty big. I was lucky to have been able to meet with the leads (my flight was delayed, so I arrived at the hotel just in time.)

Photo by Vikram Pendse

TechEd and TechDays

TechEd India covered Bangalore and Pune. TechDays India happened in Delhi in between the two.

These events are smaller than TechEd US and TechEd Europe, but the production values are just as high, with even a few extras thrown in. A couple years ago, a monkey snuck in the back door of an event hall and perched on top of the screen, watching the demos. The original code monkey :)

Here's the keynote hall for TechEd Bangalore. This was located in an outside stand-alone building.

TechEd Pune was even larger, located inside a hotel: the JW Marriott Pune. Here's Nisha presenting to a full house:

I think this was from my talk on XAML performance. I must have been explaining something pretty serious when this photo was taken :)

(This photo from Bangalore was shared to me without attribution. If you are the photographer, please let me know.)

The "Stump the Speaker" panels were my favorite part. In this photo, from Bangalore, I had so much Q&A at the end of my session, I arrived late to the panel, and got the honorary tall seat.

Photograph by Microsoft, India

TechDays Delhi was a free event, so it attracted a lot of local students. I was pleased to speak with this audience, as getting our tools, and our guidance on quality apps in front of them is really important. Students are responsible for some of the most exciting startups and some of the coolest apps.

Finally, one thing that I thought was done extremely well at TechEd India was the keynote by four children. Take a moment and watch it now.

The must-see demo from TechEd India

My session decks for the TechEd events are available here: https://india.msteched.com/ Click on "downloads" at the top right. My three sessions were:

Addressing Performance in Windows 8 XAML apps (day 1, architect track)
Tips and Techniques for Building High Quality Windows 8 apps (day 2, Windows 8 track)
Smoothly Navigating the Windows Store Submission, Certification, and Listing Process (day 2, Windows 8 track)

Recordings will be up soon, as I understand it. I'd recommend watching Bangalore, as Pune had to squeeze sessions to account for keynote overrun, so the sessions are a bit compressed.

PCs and phones: an observation

Here are some interesting observations about PCs, phones, and tablets in India:

Almost all developers have a smart phone
iPhone is not the number one smart phone, or even the number two smart phone in India, despite their advertising there.
- Look who's doing well in India and more recent news here
- I saw only a single iPhone at the events, and not a single iPad. This includes the event the students attended.
- Total phone ownership is approximately 12x any sort of PC or Mac ownership
For car drivers and non-IT folks, that little indestructible Nokia was what I usually saw. Feature phones still dominate in India.
I saw a number of high end Android tablets and some Surface w/ Windows RT

This data all came from the local folks and my personal observations, so use it only as anecdotal data. I did see a number of Windows Phones out in the wild, outside of the events. The HTC 8x in blue seems to be quite popular there (this also happens to be the phone I own).

Students generally get new PCs before they go to university, but (anecdotally) rarely have them available to them at earlier grades.

All of this helps to show why India is more of a producer of PC software than a consumer.

Apps

There are some really well-designed apps which have come out of India. I'm not going to list them all in this post, but here are a couple I found compelling:

Sweet 'N' Spicy

And Tarla Dalal

The fact that I absolutely love Indian food played no part in me picking these two specific apps. Honestly ;) You can find them both listed in most regions, including the US Windows Store.

Being a tourist

There is a lot to see in India, especially near New Delhi.

I arranged ahead of time to have a driver pick me up at 4am at the hotel on Saturday with instructions to bring me to the Taj Mahal and the Red Fort of Agra, and to make sure it was a driver who could speak and understand English. He then drove me the 4+ hours from Delhi to Agra. Once we arrived in Agra, he picked up my tour guide for the day (I didn't know I was getting one, but this turned out to be a good idea). They tried to stop for breakfast at a place where the guide obviously had some business interests, but it was too early, I convinced them to skip breakfast and to just bring me right to the Taj. (I left at 4am, but if taking the Delhi->Agra highway, I recommend leaving even earlier, like 3:30, depending on traffic etc.)

The Taj Mahal was everything I had hoped it would be, and much larger. It always looks so small in the photos.

The Taj Mahal is also full of people looking to tap your wallet a little. Just know it's all part of the experience and keep lots of rupees on you. The photos, for example, will run you 10,000 to 20,000 rupee. They say it's 100 rupee per photo, but then take close to 20 of them. Don't worry about whether or not you got the best price or someone else was able to negotiate off 100 rupee more than you. These folks are providing a service to tourists and by western standards, it's pretty inexpensive regardless.

The whole time the tour guide brought me around the Taj, he was talking up the marble inlay. This is interesting, but understand it's also them priming the pump for the trip to the state-owned marble shop afterwards.

TIP

When you're brought to the marble shop, you'll be face to face with one or more extremely talented sales people. In my case, they sat me down with hot tea and showed expensive marble tops first, and afterwards the inexpensive stuff. Then, it was off to jewelry, and then textiles, and (I insisted they leave this part out) rugs. In the case of the marble, unless you really want a table top, just ask to be shown the small things like statues, coasters, etc. Seriously, these sales people are good. I've had less pressure at a car dealer.

Some of the marble goods are nice, though, especially at the state-owned/certified shops. The one I was brought to was an emporium. I tried negotiating for a bit, but they wouldn't do any better than a small discount off the top. From speaking with others, the emporiums are generally fixed price. The one I went to was Cottage Industries, but oddly it also seems to go by the name Cauvery Emporium, as I had receipts from both places for my purchases inside the same building.

Before going in the shop, set a firm budget in your mind, and convert it to rupees so you don't have to do the math in front of the sales people. That's the best way to avoid the pressure as you can firmly say something is outside your budget. Remember, these folks are good.

The trip around the Taj Mahal took around 2 1/2 hours. I was there nice and early, before the majority of the crows. The photo above was taken on the way out as the place filled up. It was also getting pretty hot by then.

It also gets pretty hazy as the day goes on. Air pollution is pretty bad, as is the dust.

After the trip to the Taj, we stopped for breakfast (extremely inexpensive compared to the hotels, and very good) and then headed over to the red fort.

This part of the Agra fort had a fire on the inside, set by invaders. That burned all the painting off the walls, and left a smoky colored marble. Note the translucent marble near the windows.

The "forts" in India are the castles. Don't let the name "fort" put you off, as these aren't US-style forts, and are fully worth the trip. The Agra Fort, in particular, is impressive both in construction and in history. Read up a bit on it before visiting.

The drive back from Agra took quite a bit longer due to traffic. It was over 5 hours as I recall. We also had to dodge, of all things, stray cattle lying in the gutter in Agra. Imagine stray cats and dogs in another nation and then add like 600-800 pounds. They were just there, lying down in the street, in the middle of the city. It was amusing mostly in that it seemed so normal. :)

TIP
Don't get hung up over whether or not you tipped too much for your tourguide, driver, etc. Tip what you think is fair for the service you received, and if you go by Western standards, you'll almost certainly be tipping more than enough. Keep small bills and coins around for the dude in the bathroom who won't let you out without a tip.

While in Delhi, I also took an evening tour "Sound and lights show" of the Delhi Fort. Seeing the Agra Fort afterwards helped complete the story.

You can find all of my photos from this trip on my Flickr page.

Poverty

Before I point out a few helpful tips, I wanted to mention the poverty. I've seen slum-level poverty in the United States, but I was unprepared for the type of poverty I saw on the outskirts of the cities in India. Even the Delhi Airport had slum villages right up against the walls. These villages are made from piles of debris, trash, old signs, mud, dung and more. Basically, if it can be used to put a roof over one's head, it will be. I was never able to get a good photo as cars/planes never stop near the slums. The only real photos I got were these washed out hazy ones (did I mention the pollution?) from inside the plane at Mumbai Airport (click for larger version). These were at least made of building materials. Many were just hobbit holes in what appeared to be piles of trash held together by mud along the side of the road.

You'll also see a LOT of buildings in various stages of construction. Many seem abandoned before completion. Many are concrete skeletons with exposed rebar on top, and bamboo scaffolding. Such is the nature of a developing country.

Here is an image search showing more of these slums.

Some advice for fellow westerners visiting India

I've been to a number of places in Europe, but this was my first time this far east. The culture really is quite different from European culture, so be prepared.

Dress
- Purchase really light cotton khakis before your visit. I brought jeans (too hot) and shorts (not recommended, as only kids wear shorts)
- Women should dress conservatively, especially at monuments. The Taj Mahal grounds include an active mosque and a lot of local and short shorts or low tops will likely get you unwanted attention from folks who think you're being disrespectful or tacky, or from people who want a closer look.
- Men, if you intend to visit any mosque, arms and legs must be covered.
Food
- Unlike the US, don't expect to find water/snack vendors all over the place. If you have Type 1 or other blood sugar control issues, be sure to carry stuff with you, but also know that Taj Mahal will not allow most of this in the monument
- If you don't like Indian food, you're really missing out. :)
- Always drink bottled water. Even in the hotels, stick to bottled. Avoid salads which have been washed in local water. Even my India friends who have been away from India for a while found the local water really upset their stomachs
- - Brush with bottled water as well.
Purchasing
- If you look western, expect the starting price for everything on the street to be at least 2-3x what locals would even consider paying. Negotiate what you can, but also keep in mind that this is a relatively poor country, and you're doing your part to help out in a fair exchange of goods and cash. Don't get taken, but don't worry about nickels and dimes.
- Keep rupees on you. Outside of the western-style hotels, most places are cash-only. Keep lots of small amounts too, as you'll find 100 INR is far too large a tip for some things, and too small for others.
- Use a credit card, not your debit card. You want some protection.
Airports and Travel
- Airport screenings segregate male / female
- Most airports require that you have a printed boarding pass before you can even enter the airport. Some will take a PDF on your phone, but that varies. Web check-in at the hotel.
- Use a hired car and driver. Don't even think of driving yourself. Hired cars (from a reputable company - I used Car Club) are very inexpensive. My whole trip to Agra (4am to 8pm) was around $150 US plus tips. Considering I monopolized a driver from 4am to 8pm, that's pretty good. Trips between hotels and airports typically ran around $15-$20 USD.
- If you use a video camera, realize that the monuments require you to pay extra to bring them in, and some like the Taj Mahal, make you pay to lock them up before entering the monument proper (they do not allow them on the grounds). I use my video camera as my still camera, but that didn't matter. Smart phones are fine as it doesn't seem that Indian officials have caught on to the idea that smart phones are also video cameras.
- If going on a business trip, make a point of seeing the monuments close to where you're staying. There are lots of great things around India, and the beauty can be breathtaking.

Maker Geek Roundup 018 for 3/12/2013

Pete Brown — Tue, 12 Mar 2013 06:25:58 GMT

The Maker Geek Roundup aggregates information of interest to makers everywhere. Topics include .NET Micro Framework, Arduino, AVR and other MCUs, CNC, 3d Printing, Robotics, Microsoft Robotics Studio, Electronics, General Maker stuff, and more. If you have something interesting you've done or have run across, or you blog regularly on the topics included here, please send me the URL and brief description via the contact link.

Disney Fairies: The evolution of hub screen box layout in Windows Store apps

Pete Brown — Thu, 07 Mar 2013 20:37:33 GMT

A large number of apps in the Windows Store follow the "bunch of boxes in a GridView" approach to the hub screen.

This can work in some cases, but I encourage developers and designers to move beyond that look, and consider either evolutions of it, or completely different approaches.

Boxes 1.0

For many, the basic box layout is a very workable layout. Here's one of my essential apps: YouTube+ (viewed on my desktop).

The UI us very conservative but very functional. I don't think anyone would disagree with me if I said it wasn't "beautiful" or particularly creative, but as a third-party app that can't necessarily use first-party branding, it works.

As an aside, I love the snapped view for the YouTube+ app. It's very workable, especially if you use it mostly for listening, as I do.

Boxes 2.0

Some, such as the Xbox games, improve on the stock templates by having a more varied layout. For example:

Many of the Xbox games follow this style. It's a great way to show all the game styles, your achievements, and more. It requires more effort to create this type of layout, as each of the groups contains a different layout with different data. This is truly a hub screen.

Boxes 3.0

Here's another example, from Adera. Though almost identical in concept to the earlier Xbox games like Minesweeper, the hub screen is more complex, requiring support for different chapters, and in-app purchases. I usually play Adera on my Surface, but here's what it looks like on my desktop. The background is textured, so wouldn't look correct assembled into a single image.

The colors are darker, fitting the Adera theme. The use of in-game images also really helps make the layout more appealing. Note how we're still using boxes, but the overall interface is more stylized and, to my eyes, more beautiful.

Boxes 4.0

That brings me to the game I installed yesterday. The latest game to come through is Disney Fairies Hidden Treasures. As the father of a 4 year old girl and a 7 year old boy, both of whom love the Disney Fairy cartoons and franchise, I immediately purchased it. When I ran it, I was pleasantly surprised by the hub screen. Here, take a look:

This is a game which, I assume, is primarily targeted to young children, typically girls. The gameplay is simple enough that young kids will certainly enjoy it. As part of that targeting (and overall branding), the design team has taken the boxes hub to the next level. Check out the styling of the hub screen in this close-up:

Yes, there's adornment around those boxes. However, it completely works as it's minimal and appropriate both to the brand and to the game itself. The layout follows well-known Windows design patterns, but takes it to the next level.

You can see how the branding was brought forward from the game tile.

Now look at the same general section from Adera. You can make out the same elements, but in a less stylized fashion. A stock font is used, and the game itself doesn't have any real branding at the top. Note also the use of color in the Fairies navigation chevrons as compared to Adera. You can see how the use of color (and shading in that case) helps those stand out. Adera does use some background styling which, in this case, makes all the difference in helping set the mood for the game.

It would be nice if they used the Adera branding at the top to better tie in with their tile:

And now, a similar concept from Minesweeper. This is one of the very early games, and it follows a conservative Windows style. There's no texture in the background, and the fonts and branding are all stock. Of course, this is Minesweeper, not something that you'd expect to be heavily stylized or branded.

Do you see the progression between the three?

Some take-aways

I wouldn't expect everyone to have Disney-class design support for their apps. However, there are some things we can take away here.

1. Branding is very important. Bring your brand forward in the game, and be consistent in its use. Matching the branding used on your tile is a good idea.

2. Using a custom font as part of your branding can really work. It needs to integrate with your branding and with the app as a whole, but it doesn't need to be limited to Segoe UI.

3. You don't need to limit yourself to box layout. If you do, however, you can use additional design elements to help that layout pop. Keep in mind that the content is the most important, so be careful that the adornment is not the focus.

4. Sometimes, a background texture can help change the UI from something boring to something very interesting. You need to use good design sense when doing this, and not slap any old darkened stock photo in the background.

Oh, and unofficial take-away number 5: if you have younger children who like Disney Fairies, pick up Disney Fairies Hidden Treasures. It's a great game for them.

Do you really know what your kids are doing online and in games?

Pete Brown — Fri, 01 Mar 2013 05:29:14 GMT

It seems that each generation is exposed to more mature or serious situations at earlier ages than the one before it. There are a lot more ways for kids to get in trouble online than just running afoul of the creepily mustachioed basement dweller you see on "that" episode of Special Victims Unit.

tl;dr: A child was banned from Xbox live and that caused me to investigate some things which, in turn, surfaced a lot of other stuff. Unless you're really watching closely, you almost certainly don't know what your kids are doing online. Kids are clever.

I know a child, not my own, who is 9 years old. Let's call him "Nine". He's a great kid, has excellent conduct scores in school (never once has he had to be disciplined in school). He's fairly shy and generally keeps to himself. He's really a great kid.

One thing he does like doing is playing on his Xbox 360. He has a neighbor friend who is 10 years old, who sometimes comes over and plays on the same console. We'll call him "Ten". This 10 year old "wants to be a hacker" when he grows up. He also has a 360 at his house. From the sounds of it, he's also poorly supervised when it comes to computer and gaming time.

Recently, Ten manually updated his Xbox gamer profile and changed his tenure and some of the avatar's appearance. At the same time, he helped Nine change his avatar's appearance. Now, understand that to do this, you have to go to some of the seedier corners of the Internet and use tools which download your gamer profile, update the file, and then re-upload it. The use of these tools violate the Xbox terms of service and are considered an offense worthy of a permanent ban.

Yep. Both kids were banned until 12/31/9999. 9999. Harsh, I know, especially if you are an otherwise good 9 year old. That said, as bad as I feel for Nine, I completely support it.

They got a rather vague email from the Policy & Enforcement Team telling them about the ban. Through the same channels as everyone else, I was able to ask support for some (slight) clarification as to what happened. That's how I found out they had modded the gamer profile. (BTW, take a moment and watch that linked video. It's really good)

As part of that ban, both kids completely forfeit their remaining Xbox gold balance. (As well as everything else associated with their gamer tag, the least of which are their Cheevos). For Nine, that means the $50 of birthday and Christmas money he saved up to get that 12 month subscription is now gone. Wasted. I'm not sure if he had downloaded content or games, but I believe that gets lost as well.

My 7 year old son uses the Xbox under my Live account. After seeing how the ban process works, you can bet that will stop once he starts playing Xbox by himself, especially now that my gamer tag reaches into my Windows 8 machines and my Windows Phone. There's a lot to loose if you break the rules.

Mom of Nine had no real idea what happened, so I helped her investigate. As part of this, I was able to see both Nine and Ten's gamer history using public sites on the Internet (this is easily discoverable online for accounts which don't keep it private). I saw some things in there that made me sit back and question what these kids are being allowed to play.

That got me to thinking about what games are appropriate and how much parents should watch what their children do. I also had a long talk with Mom-of-Nine about some of these topics. This post is a bunch of loosely related "stuff" that came up as part of this. I'll start with games, but then get into privacy and security.

Game Appropriateness and Ratings

In both children's gamer tags I found, among a number of other games, the following:

Both are rated M for mature, which technically means 17+. The problem is, many otherwise fun and arguably harmless games are rated M for mature, so the on-box rating has become an almost meaningless mark when it comes to evaluating games for pre-teen, tween, and teen kids.

The real issue is that the Mature rating is a large bucket under which a lot of stuff gets thrown. The Mature rating isn't alone in this. For example, I let my 7 year old son and 4 year old daughter together play the various LEGO games on the Xbox (Star Wars, Harry Potter, Batman) -- those fall into the 10+ category.

There are a number of sites online which do parental reviews of video games. Some of them have agendas and biases, and some get overrun by kids posting as adults, so you really just need to find a site which fits with your own values and which appears to have relevant reviews. My kids are not yet at an age where I've had to research using one of these sites, but they're out there. For example, here's the parents review for Halo 4 and here's the review for Grand Theft Auto IV

I'm not going to make a value judgment for you, nor do I want to start a discussion about what is appropriate for children as we all have our own rules. I'm also not trying to make a martyr out of particular game here, or suggest games can corrupt or anything like that. Both games are considered excellent games overall. That said, most parents put more effort into selecting movies than in video games. (How many would let a 10 year old see Goodfellas? A Tarantino film? Showgirls? Yet many are fine with games of equivalent nature.)

Halo is very violent (4 out of 5 points) and involves a lot of battles typically in a "shoot the guy over there" first person shooter style. The only sexual content is the scant cladding on one character (1 out of 5 points for sex). There's no foul language or drinking, drugs, or smoking.
GTA IV is violent (5 out of 5 points), but also contains "adult" language (5 out of 5 points), drug references (as part of core gameplay - it got 5 out of 5 points here), calling police and then shooting them when they arrive, killing drug dealers, and a fair bit of sexual content (scored 4out of 5 points in that area), prostitution, lap dances, porn shops etc. The violence itself is at more of a "personal" level.

Again, both of them have the same rating. Depending upon what you find concerning, you may disallow both, or just one of them, or maybe you're fine with both (one parent of a 9yo on the reviews said GTA IV is fine for her son). Regardless, you can't tell that by looking at it on a store shelf; you need to read reviews of the game. Interestingly, the reviews generally agree that GTA IV is appropriate for 13+ and Halo 4 for 12+. Both of those are a far cry from 17+.

I'm of the camp which doesn't believe video games turn kids into killers, but I also don't think that means one should expose their kids to violence, sex, drugs, etc. before they are mature enough to understand what they're looking at, and make appropriate real-life decisions.

As parents, we need to understand the nature and content of a game before we purchase or allow the purchase of those games. More importantly, we need to discuss the themes of the games and get our children to think about what messages the games are sending them. We often do this for television, games are even more immersive.

Dangerous Activity

There are lots of places where you can get in trouble online. From viruses and malware to chatting with basement neckbeards, to posting inappropriate photos of themselves. Kids are naturally curious and also feel like they are impervious to harm. Combine this with perceived anonymity of the Internet, and you can get into all sorts of bad spots.

Dialogs

Teach your child not to click-through dialogs without reading them (if they are old enough) or having you read them. Unless you enjoy malware, extra toolbars, or other scary stuff on the machines, this is essential.

Chat and Email

If you've ever watched Law & Order, you know that chat can be a bad place for kids to hang out. They're also a place where kids can release private information in a way that is hard for you to track. Same goes with Facebook chat and even email. The younger the child, the more you need to control how these communication mechanisms are used. My 7 year old son has an email address, but only for sending email with me. It helps his typing and reading skills and it's fun. It has also helped him be smarter about how to read email and how to judge. Eventually he'll use it to email others (we'll start with a couple of his same aged friends), but we'll shepherd him through that.

Pictures and webcam/video

When I was young, taking and sharing a photograph required several steps:

You had to decide that what you were taking a picture of was actually worth the film it would use
You had to wait for the film to be developed (the quickest was typically an hour). A clerk *saw* the photos when they came off the line, and if you had something illegal, you could be reported.
If you wanted to share the photo, you had to physically show the paper photo to someone.

Each of these was a possible inflection point which helped prevent impulse decisions. A politician couldn't simply make an impulse decision to unzip, snap, and tweet all within a matter of seconds. If you really wanted to expose yourself to someone, it was easier to just go see them in person.

In general, I tell people never to send to anyone else anything they wouldn't be comfortable having broadly shared. This is especially true of photos and video, especially *those* kinds of photos and video. There have been many stories of politicians sending photos of their junk to girls and assuming those would somehow be kept secret. That takes a special kind of stupid. Even more common are photos shared with boyfriends/girlfriends which become Internet fodder after a bad breakup. They meant well, and in the heat of the moment, it felt like a fun thing to do. However, it's rare to find someone who marries their high school sweetheart, so just assume that anything you share could become public in a couple months or a couple years. If you're uncomfortable with that, don't share it with anyone, not even that special someone.

If you share it with anyone, you can't guarantee its privacy. Especially during childhood, kids who are friends this week may be bitter enemies the next. That information you shared with them? Those pictures? Expect them to show up on facebook, or 4chan, or worse. Once something gets on the Internet, it's almost impossible to remove it. Search engines index too quickly and stuff goes viral faster than ever. The best way to keep things private is not to share them.

Online Privacy

I'm calling privacy out separately, even though much of this could easily fit under the heading of Dangerous Activity.

Many of us have heard that when you get a new expensive device (like a big screen TV), that you should take the box directly to the dump and not leave it on your curb. This is so potential thieves driving by your house don't get a heads up to the new things you have inside. This just seems like common sense … to an adult.

Many of us also know not to post information about these things online. Even if you think a thief couldn't figure out your address, it is surprisingly easy to do so. There are many address search sites available, for one. For another, many people post their addresses (or cities, or more) to social networking sites like Facebook, or mention them in twitter. Usually all it takes is a simple Google/Bing search to connect the dots.

Kids breaching your privacy

But maybe you're extremely careful. Maybe you don't have any of that information online. That's awesome. But now your kids are online - will they spill the beans on you? We worry about kids' privacy, but what about what they do with *your* private information?

Do your kids know not to:

Mention the school they attend (this one is especially hard)
Put their address or phone number on anything
Talk about what their parents do for a living or how much they make
Mention when their parents are or are not home
Announce when the family is taking a vacation (this includes tweeting or facebooking while on vacation)
Talk about that cool big ticket item the family just purchased
Post photos of themselves online

"Hey, nobody is home" is a big one. For me, I generally won't tweet or facebook about a vacation until I return. Sure, that's not as fun as doing it live, but it's safer. Plus, if you're on vacation, get off the damn Internet and try to pay some attention to your family. :)

Social networks

Those things can be hard, because kids naturally love talking about stuff like that. The problem is, with services like Twitter, and increasingly Facebook, it's hard to control who does or does not see those things. The business models of most social networks require them to offer as little privacy as possible. One even came right out and said it. (paraphrased) "Privacy is for old people".

Think about it: Facebook needs you to share as much as possible. It also needs to make your information available to advertisers, and to the public web. If Facebook made everything private by default, they would wither and die. Just like credit card companies telling you your privacy is important to them (bull), know that social networks don't have your privacy as their top priority. Unfortunately, this makes it even harder to keep your kids safe, and to make sure they're keeping you safe in turn.

Each and every piece of information you post on line, no matter how small, should be evaluated:

Could this information cause harm to anyone else if it got out?
If the wrong people saw this, could it cause me harm?
Am I sharing information that is private to someone else? Is it my secret to share?

But what's that, you say? Your child doesn't have a Facebook account? I wouldn't be so sure about that. Facebook may have a policy which requires you to be at least 13 years old to sign up, but it relies on the honesty of the child. It's completely unverifiable and unenforceable. I personally know a number of kids who are on there who are well under 13, and I've talked with parents who later found out their kids had facebook and twitter accounts. Every day, parents find out their kids have social network accounts, created without permission. Just like you would talk to your kids about sex with the assumption they're not going to ask your permission to mess around, you should talk to them about social networks and privacy proactively.

Their personal brand

I encourage people to create "real" accounts for their kids, as you don't want to have to start over at some designated age. That has the fortunate, or perhaps unfortunate, effect of causing someone's personal brand to start at an early age.

I personally *do* want my things from ten or fifteen years ago showing up on the Internet. I have had a lot of neat projects in that time. But think of how many changes a kid goes through in the same amount of time.

Even today, I can search the usenet archive and find posts from when I was 19. Those were embarrassing, but not horrible. Back then, we didn't know this stuff would be around forever; the Internet was relatively new and just recently opened to the public. It's routine for employers to google/bing their prospective employees before bringing them in for an interview. Sure, you may think they'll take into account that they were ten years younger when they posts that obnoxious rant, but reality is, they probably won't even if you're lucky enough to have the material dated. You're dealing with real people reviewing this material, and what they see *will* color their opinion. Those racist/sexist/offensive/obnoxious comments at age 13, written on Facebook or Twitter? Yes, they will cause you problems in your job search at age 23, and 33, and probably even 43.

This can be an extremely difficult lesson to teach as a child or teen is probably not going to understand (or care about) what a professional profile should look like. As a parent, it'll be your responsibility to help them with this so they don't ruin their future chances at college.

You may think that the best route would be to then create a "temporary" profile. The problem is, when you go to transition them to the "real" profile, they'll have too much invested in the old one. Even if they are able to transition, they'll have to leave lots of pointers and breadcrumbs linking the two, effectively negating the effect of having a temporary profile to start with.

Illegal Activity

Of course, most of us are aware of the illegal activity that kids can participate on online. However, we're generally not aware of how easy it is to do so.

Pirating and illegal downloads

I'm not making a statement here on DMCA or copyrights. As an author, software developer, and employee of a very large software, devices, and services company, I do my best to respect copyrights. At the same time, I can see and understand some of the damaging effects of over-long and overly strict copyrights both for authors/artists, and for consumers.

Groups like the RIAA have really cracked down on illegal downloads of music and video. If caught, your child could cost you jail time and a significant amount of cash. It's in your own best interest to make sure your child knows not to download illegal software or music. Question anything your child gets "for free". Some things are legitimately for free, others are malware, and others are warez/pirated and could land you in a heap of trouble.

Regardless of your personal feelings on the DMCA and whether software/music/etc. should be free, understand that you or your kids breaking the law here can cost you dearly. You are responsible for what your children are doing and cannot claim ignorance. And yes, the RIAA has gone after individuals.

Hacking

The first movie I saw which really connected with me with regard to computers was WarGames. Even in that movie, hacking is very glamorous. In later movies, hackers always had really cool FUI with 3d models and other cool representations of the "codes" they were trying to crack. It looks like a lot of fun, until the feds come by and throw you in a van.

The reality is, hacking is typically either scary professional crime organizations, or kids getting in over their heads messing with stuff they never should, trying to be cool. The proliferation of hacking "kits" makes it easy for even young kids to hack stuff. Technically, the Xbox stunt which prompted this post is considered hacking. Jailbreaking your phone? That's a type of hacking. Stealing someone's facebook password? Yep.

Children should be taught to never try to get someone else's password, to never access stuff they don't have explicit permission to, and to always ask for your advice when it comes to gray areas. In general, if they need to download an additional program to access "features" not otherwise present in something, you should look closely at the source of that program and whether or not it might violate any agreements in place.

Bullying

Not too long ago, the idea of online dating was laughed at. But then it took off, and is now a huge industry. Similarly, the idea of online bullying used to be laughed at. (and if you call it "Cyber Bullying", I'll laugh at it. Please stop using the term "Cyber" unless you're talking about world-destroying robots.) Many parents still don't consider online bullying "real" bullying until their own child is a victim of it.

Many schools and organizations have very strict bullying policies in place. When I was younger, typically you'd get suspended for fighting in school. These days, bullying can land you and your child in deeper stuff, including the court system. Bullies no longer need to be the over-hormoned kid who was kept back twice; it can be the mousy girl in class, the nerd, the jock, anyone. Online bullying also leaves an even easier to follow trail than just beating someone up "behind the Kentucky Fried at 3:00" (that's where everything happened in my junior high), which makes these lawsuits even easier.

I don't want to sound like an after-school special here, but teaching your child about bullying, both to prevent them being a victim but also to prevent them from being a bully themselves, is an important part of the set of online tools you'll provide them. Children need to be taught never to share private information about others, and never to text/tweet/facebook/message anything they wouldn't say to someone in person. A good rule of thumb is "Don't be mean".

What you should do

Despite me filling this post with things you should do, I'm not here to tell parents what to do. Each parent has their own style for raising their kids, and that style is typically a very personal decision. As a concerned parent, and someone who stays up with technology and software, I just want to make sure this information is out there.

Please don't ban your kids from using these services. If you do, they'll just do it out of your sight and out of your control. That's how kids are. It's better to have them do it where you can monitor and guide them. In all honesty, I'd much rather my son (or daughter) stumble across porn on the computer at the kitchen table rather than over a friend's house when the parents are gone.

I think the worst thing you can do is shut down your kid's access to online services, or set up some sort of Net Nanny or other blocker. In the former, your kid will simply take their activities to places outside your sight (friends' houses, school, the phone, etc.). In the latter, the nanny software will simply be a challenge to the kid, and a false security for you. Most on-computer blocking software is complete crap, and also blocks legit content. Plus, kids will find a way to work around it. My son got a Nintendo DS at the age of 6. Within a few hours of me setting it, he brute force cracked the PIN which disabled connectivity and 3d. Seriously, he just sat there and tried number after number until it let him in. He was 6.

Instead, I encourage you to tell your kids the reasons behind the decisions to restrict certain activities. And then, depending on the child, you either need to actively monitor what they're doing, or you trust but verify. For my kids (ages 7 and 4), they are only allowed to use the computer in the public places in the house (the kitchen table), and we routinely check on what they're doing. More importantly, they know which places they are allowed to go to, and know to ask permission to use anything else. We're not so naïve as to think that will always work, but it's working well enough for now. I can only hope that by the time their curiosity gets the better of them, we've instilled enough knowledge and values to help make up the difference. Well… a little, anyway :)

What we should do as a community

In addition to the parental tasks, we should help the non-technical parents. One fun way to do this might be to create a package insert for new laptops. I recommend this in humor, but a serious interpretation of this could be really useful as general consumers are buying computers and phones for their kids without realizing what can be done with them.

If you're good with graphics arts, I suggest that we should create a universal Ikea-like diagram that is included with each new computer and phone. It should include:

Don't let your kids post personal information
Don't let them send nude photos
Don't let them pirate stuff
Don't bully or let others bully. Don't be mean. Don't lie about others or spread lies.
Monitor webcam usage
Do keep tabs on what your kids are doing
Do teach your kids what they should and should not do on a computer
Do assume your kids are clever enough to fool you

I think everyone would be able to understand that. :)

Using CallerMemberName for property change notification in XAML apps

Pete Brown — Mon, 25 Feb 2013 21:34:25 GMT

.NET 4.5 quietly introduced several attributes which are useful for debugging and error reporting: CallerMemberName, CallerFilePath and CallerLineNumber, all collectively referred to as "Caller Information". One of those, CallerMemberName, is also very useful for MVVM apps and other apps using INotifyPropertyChanged for change notifications.

Getting the calling function name

The CallerMemberName attribute, from the System.Runtime.CompilerServices namespace, supplies the name of the function which called the function with the attribute in its parameter list. For example, if you have a function defined like this:

private void DoSomething([CallerMemberName] string callingFunction = null)

{

    if (callingFunction != null)

        Debug.WriteLine("Calling function name is " + callingFunction);

    else

        Debug.WriteLine("Calling function not supplied.");

}

Then, you call it like this:

private void CallSomething()

{

    DoSomething();

}

The callingFunction parameter will be filled with the name of the calling function. In this case, the output indicate that the calling function is "CallSomething". This works because the property uses the CallerMemberName attribute and has a default value. The default value is a required part of this pattern.

Using CallerMemberName in property change notification

XAML uses an interface and event based property change notification pattern to alert the binding system when a non-static property has been changed. (WPF supports binding to static properties, and although it uses the event, it does not use the interface as there's no class instance.) The interface used is INotifyPropertyChanged, and regardless of how you feel about the requirement to use this interface for change notification, it seems it is here to stay.

The problem

One real issue with INotifyPropertyChanged is the requirement to pass in the name of the calling property as a string. Some time ago, I spoke with the people who originally designed this approach, and despite me not caring much for it, I'm convinced that it was, in fact, the correct approach to use. It provides the best performance and flexibility compared to other approaches, and required no changes to the language specs or the CLR.

Code using this approach, without the benefit of any MVVM toolkits or other base classes, typically looked something like this:

public class PuzzleLevel : INotifyPropertyChanged

{

    private string _title;

    public string Title

    {

        get { return _title; }

        set

        {

            if (value != _title)

            {

                _title = value;

                OnPropertyChanged("Title");

            }

        }

    }



    // ...



    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)

    {

        if (PropertyChanged != null)

            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

    }

}

This leads to countless problems when properties are refactored and renamed, but the string (which is not verified by the compiler) is not changed. For example, here' I've renamed the Title property to Name. This will compile just fine:

public class PuzzleLevel : INotifyPropertyChanged

{

    private string _name;

    public string Name

    {

        get { return _name; }

        set

        {

            if (value != _name)

            {

                _name = value;

                OnPropertyChanged("Title");

            }

        }

    }



    // ...



    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)

    {

        if (PropertyChanged != null)

            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

    }

}

Not only will this compile just fine, but it will run as well. The only real indication of a problem will be the field not updating in the UI when changed from someplace else in the code, or another part of the UI. This can be really easy to miss in testing.

The solution

There are multiple ways to solve this, but the newest, and perhaps most elegant, is an approach using the CallerMemberName attribute. This approach is used by the default Windows Store XAML app templates in the BindableBase class:

public abstract class BindableBase : INotifyPropertyChanged

{

    public event PropertyChangedEventHandler PropertyChanged;



    protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] String propertyName = null)

    {

        if (object.Equals(storage, value)) return false;



        storage = value;

        this.OnPropertyChanged(propertyName);

        return true;

    }



    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)

    {

        var eventHandler = this.PropertyChanged;

        if (eventHandler != null)

        {

            eventHandler(this, new PropertyChangedEventArgs(propertyName));

        }

    }

}

If you were passing in strings for property names before, this base class will simplify your code and also save you from the difficult-to-track binding bugs you'd get if you changed property names without updating the string in the property change notification call. Now, your setters can be as simple as this:

public class PuzzleLevel : BindableBase

{

    private string _title;

    public string Title

    {

        get { return _title; }

        set { SetProperty(ref _title, value); }

    }



    private int _highScore;

    public int HighScore

    {

        get { return _highScore; }

        set { SetProperty(ref _highScore, value); }

    }



    private bool _isLocked;

    public bool IsLocked

    {

        get { return _isLocked; }

        set { SetProperty(ref _isLocked, value); }

    }

}

There were other ways to do this, but they all involved more steps and additional parameters. The use of third-party MVVM toolkits and lambda expressions simplified that somewhat. Those will still work and work well, but for new code, I recommend you consider using the built-in CallerMemberName attribute approach.

The CallerMemberName (and other Caller* functions) are changed into literal values at compile time, so there's no runtime reflection lookup or similar performance hit like that encountered by other methods. This, combined with its ease of use, makes it a no-brainer to use.

This approach also works with VB with appropriate syntax changes.

Getting more visibility for your Windows Store app Part 1: Create great apps

Pete Brown — Wed, 23 Jan 2013 07:47:29 GMT

Many developers ask me how to get more visibility for their apps in the Windows Store. Most do not realize, that even on the public web, visibility is almost never organic. It's the result of hard work on the part of all involved. In this first post I'll provide some observations as to things that I personally think help increase app visibility, specifically, app quality. In part 2, I'll cover the listing and promotion side of the equation.

DISCLAIMER: I'm not a marketing person, and I do not have inside knowledge of the Windows Store ranking and sorting algorithms. Additionally, I do not have metrics which empirically prove any of these techniques work. This is just advice based on my own observations, primarily targeted to people who are new to publishing apps in an online store. This is not a replacement for the Develop Great Apps content on our dev center.

The single most important thing you can do to increase the visibility of your app is to start with a great app. Full stop. All other things equal, a great app will do better than a mediocre app or a terrible app. Here are some suggestions for things which can help tip the scale from "meh" to "yeah!"

Don't create throwaways

Back when I used to work for Scott Hanselman, one recurring piece of advice he'd give to the team was "Don't create throwaways". He was talking about blog posts then, but the same thing applies to apps. Throwaway apps can ruin your reputation with customers and also with the Windows Store. The Windows Store is not a great place to post things like little test projects or homework apps. You can do those easily and share them with your testers using documented side-load capabilities.

Each and every app you put in the Windows Store should be an app you're proud of. It should be something you wouldn't hesitate to show your friends, family, and your colleagues. It should be useful and engaging. In fact, the number one requirement in the Windows 8 app certification requirements is "Windows Store apps provide value to the customer". Put another way: Your app needs to be worth the download time and storage space, or else it's going to get a bad review.

Apps don't need to be perfect, or masterpieces, but they need to be apps that will raise your overall reputation. If you thought of, designed, and coded the app in an evening, chances are you can do even better if you take a few more days :)

Don't be tempted to put a rough draft out into the wild. As the old saying goes, you only get one chance to make a first impression. This is as true for apps as it is for dating.

Go beyond the stock templates

I do a lot with music both in the app world and with hardware synthesizers. A common complaint is when a synthesizer preset gets used by many different artists as-is, without any substantive customization or modification. It becomes the only thing you hear in the song. Some get so over-used, even when slightly modified (M1 Piano, DX7 E. Piano 1 (and this) and slap bass, D-50 Fantasia, JP-8000 supersaw (which I still like, but that's besides the point), Alpha Juno "Hoover" etc.) that others start to rebel against them. The recommendation is to start with stock patches, but to customize them, or just create new ones from scratch. Otherwise you'll sound pedestrian, dated, and maybe even like a copycat. Presets are in synthesizers just to give you an idea of what the machine is capable of, sound designers didn't expect to hear them on actual records.

The built in templates in Visual Studio are a great starting point for structuring your app. However, like the synthesizer presets, they were never meant to be used exactly as-is. They are a starting point to help you get from zero to working in a very short period of time.

Here's a screen shot of one of the built-in templates running on my 30" screen.

Notice how each square is the same 250px with a text overlay at the bottom. There's nothing there to mix it up. It's a starting point - a preset. It's deliberately grayscale so that you don't fixate on existing colors while you flesh out your ideas.

The Windows design aesthetic doesn't limit you to a gray app with a bunch of 250px squares with a text overlay at the bottom. Think, erm, outside the 250px box.

Once you've proven that the functionality of your app works, then you can get creative with the UI. Customize it with appropriate branding and logos. Change the sizes of tiles, if you decide to stick with a tile layout at all.

Here are some apps which use simple box layouts, but do it in a good way that is different from the stock templates. Some vary the sizes of the boxes, some simply alter the layout of the main screen. Both use branding and colors. This is a very conservative approach which looks good, but relies on amazing content to carry the app. Keep in mind that you're seeing these all on my huge screen.

I've seen an increasing number of apps in the store which use rectangles and even the labels as shown in the stock templates, but mix it up enough to be different and interesting. For example, most of the Xbox games on Windows have a hub screen which is not quite as conservative as the previous two, but still rooted in the same design principles. Note the use of boxes which span more than one row or column. Note the use of color. This is a simple design which any developer could pull off.

Xbox video takes a similar approach.

Top Gear News from the BBC is another app which sticks with a general box layout, but is far from being a template app. This is a portal-type app where the content is highlighted in the app but hosted on the web site.

(Please note that none of the above three are optimized for a high resolution, low DPI screen like mine. More on that later):

(The built-ion News app is another great app with a variation on the box layout. No screen shot today, however, as it doesn't feel right to post that with the headline story being about the college shootings.)

How about some other interesting boxes? The FX app leans towards the boxes side of the design aesthetic, but manages to have an engaging and very attractive UI, again, without sticking to a pure template layout. The app also scales well to different resolutions.

My wife and I share a Kindle account (we set it up before Kindle supported sharing). Here's what the Kindle app hub page looks like when you're signed in (I don't read books on this PC. I use my Surface for that). It's not the same type of boxes we've seen before, but it is appropriate to this app's audience. Notice also the use of branding logos and colors on the top left.

Enough with the boxes

Then you have other apps which eschew the boxes and go their own way (you can thank me for that, later). There's nothing in the design aesthetic which mandates the use of boxes in your layout. Grids are recommended, but we don't have any commandments you absolutely must follow when laying out your content. As long as you're consistent in modes of interaction and with system-provided tools (app bar, charms, navigation), and the app is attractive and usable from mouse, touch and keyboard, you should feel free to experiment with design that is appropriate to the brand, domain, and audience. An example of this is Nook. Notice that Nook also takes advantage of the extra space on my huge screen.

They don't look like boxes, but we're still on a grid layout. We still have side scrolling. How about a couple apps which move even further away from the boxed layout design:

(Did I mention I have a four year old daughter? The dress-up app isn't mine. Honest!)

The Disney app still uses side scrolling and has obvious touch points. It just works well. The Lola math game has no such box layout, but has obvious places where the user would interact with the screen and works well with touch and mouse. My 4yo girl picked it up without any problems at all.

You can see that although most of these use the hub page boxes-style layout, none of them look exactly like one of the built-in templates. Each has changes in color, styling, branding, and most importantly, layout which works for that specific app.

Several of them (and many other apps) do, however, fall down a bit when it comes to targeting people with giant screens like mine. Let's look at that.

Be resolution and DPI aware

When you write apps for Windows 8, you're writing apps for PCs. Apps need to work on everything from 1024x768 all the way up to low DPI 30" screens at 2560x1600, and smaller high DPI screens running at similar resolutions. Much of the DPI work is taken care of for you automatically by the runtime, and scaling to different resolutions is easy.

High DPI

High DPI screens are ones where there's a high resolution but small physical size. On these types of screens, Windows typically installs at a higher DPI setting where one pixel in your app is multiple physical pixels on screen. The additional pixels are used by vector graphics and fonts to make edges smoother and crisper. But when it comes to bitmapped graphics, you need to provide different DPI versions in order to maintain crispness in the display. Luckily, this is REALLY easy to do by simply naming your images following the scale naming convention. Visual Studio even has support for this for the logo graphics.

High Resolution

Higher resolution, low DPI screens take a little more thought on your part. You generally have two choices:

Show more content on the screen
Make everything bigger

I've seen both done successfully. The second ("make everything bigger") works well only when you have high resolution bitmap graphics or you are using all vector content. In XAML, you can use a ViewBox to make this happen for you. The former ("show more content") works well only if you have sufficient content to fill the screen. The stock itemscontrols (ListView, GridView) typically work well in this scenario.

Unfortunately, many apps take a third option: just center everything in an area optimized for 1366x768. On a large screen, this looks terrible. I won't pick on specific apps here as I'd rather work constructively with those app authors to see how they can make better use of screen space.

While you're there making your app scale nicely, you can use the same code and layout to make sure you support Portrait, Landscape, Snapped, and Filled views. The default templates provide a great way to structure these notifications and layout changes. Endeavor to make each view as functional as possible.

Testing DPI and Resolution

We don't all have access to giant screens, or high DPI screens, so we need to use the built-in tools. The Simulator in Visual Studio lets you run your app at different resolutions and DPIs just to verify that elements are laying out as you'd expect.

Support different processors

My desktop machine is a water-cooled overclocked processor with 6 cores and 12 logical processors and 12gb memory. I have a 16gb quad core laptop as well. My son has an older netbook with something like 2 or 3gb. My wife has a core i5 machine with 4gb memory. I also have two surfaces, each with ARM processors running Windows RT. All of those Windows 8 PCs are just in a single house.

The power of the Windows ecosystem is choice. There are currently over 1,700 systems certified for Windows 8. Now, before you think "holy crap that's a huge test matrix" consider that this is no different from what PC manufacturers have had to test for in the past, except we've made the API more uniform and have made the OS version matrix far smaller.

I'd encourage developers with serious apps to test on:

A developer class desktop or laptop with high resolution display. This should have discrete NVIDIA or AMD graphics, also preferably an SSD. No touch.
A typical laptop with integrated graphics and a spinning rust hard drive, touch optional but a good idea.
Possibly an older (2-3 years) laptop without touch.
A Surface or other Windows RT device with touch.

That, to me, provides a decent look at performance at a CPU level. Now, if you're a game development house, you likely have a much larger matrix, covering different makes of video cards with different capabilities, for example. Again, we've made that easier in Windows 8 and Windows RT, but you'll still want to continue that practice.

But what's the independent developer to do? For you, I suggest testing on your development PC and a Windows RT device. Consider it a good excuse to get a lightweight and low power tablet (I know I love mine). For other performance testing, invite some friends with different laptops and side-load the app on to their machines for testing. Make a party out of it (but realize you'll get the most, umm, useful feedback before the party gets too far along). It's easy to do and you'll get great feedback not only on performance, but your friends will be blunt with their assessment of your app as well.

Many developers ask me "if I'm targeting ARM, do I really need a Surface to test?" Yes, I consider a Windows RT device, such as a Surface, essential for testing anything but the most basic of apps. We've done a ton of work to unify the development model across all of Windows 8 and Windows RT, but at the end of the day, ARM is a completely different architecture from x86/64. I've worked with developers who discovered race conditions in their apps that were masked on x86 but which showed up on ARM, for example. Plus, for many developers, it would be their only touch device, and you really do want to understand how your app performs on a true touch device.

If you can't pick up a Surface (or other Windows RT device) yourself, you could solicit the help of local or international friends who could test on their own Surface. The Internet is a wonderful thing.

Don't be an island: support searching

Most apps have data which can be searched. Sometimes that data is external, on the web. Sometimes that data is just files stored on the file system. Sometimes that data is structured and stored in a database. In all cases, these apps should support the search contract.

Adding search contract support is quite easy, and you can use it to replace any built-in search you were going to include in your app anyway. You can learn more about searching on MSDN, and also in my book Windows 8 XAML in Action.

Use the built-in file pickers

The days of all the user's data existing on their local machine are, if not already long gone, well on their way out. These days, a file might exist locally, or on a server, or on a social network, or cloud storage. Or maybe, just maybe, the file doesn't exist in a physical form at all! WinRT provides an easy way for apps to integrate with file pickers both as consumers and as owners of content. You could, for example, provide a file picker interface for your app which pulls data from a database and assembles a file on-demand.

Back to the music scenarios: imagine that you want to load a sample or loop into your app. Another app could serve as a file picker, but only for content you purchase. You could then easily use that purchased content in your music creation app.

(figure from Windows 8 XAML in Action)

By integrating with file pickers as a consumer, your app doesn't need to know where the files came from, or how they got there. It simply simply needs to work with the StorageItem class and the file picker interfaces. These are your new OpenFileDialog and SaveFileDialog, so get to know them well.

You can learn more about the File Open and File Save pickers on MSDN (and, as with most of these topics, also in my book).

Sharing is as important now as it was in Kindergarten

One of the first things you're taught in Kindergarten is to share with others. Why? Because it forces interaction with others and helps take a bunch of loners and turn them into a classroom.

An app that can share to other apps will gain visibility through that share. For example, if your app can share photos it creates with other apps, there's a better chance those photos will show up on social networks like Twitter and Facebook.

An app that can be the target of sharing will be indispensible to users. For example, if your app can take shared music files and post them to SoundCloud or MySpace or BandCamp, or shared videos and post them to Vimeo or YouTube, the user will come to rely on your app for those operations. Your app becomes an integral part of the system, adding value to every other app in Windows, and serving as an important gateway to outside services.

There are a number of different formats which can be shared, from simple URLs and text to whole files and HTML markup. Support as many of these as makes sense in your app.

You can learn more about sharing on MSDN.

Draw your user in

Let's assume for a moment that you were able to get the user to download and install your app (the topic for the next post). Once installed, a good app keeps the user coming back for more. It does this by keeping content fresh, if it is a content app, or by just being an indispensible part of the user's workflow.

The Start Screen Tile

An attractive tile is important to getting the user to use your app. It needs to be obvious and clear. It should also be attractive, and not look like it was a last-minute design asset thrown together in Paint. :)

Content apps and games can both take advantage of live tiles on the Windows Start screen. Content apps can show slideshows of the content, working under the assumption that it is the content that is the draw, not the app itself. Games can, similarly, entice users to continue playing by showing progress so far, how many steps to the next level, etc.

Make use of the available layouts in the tile template catalog and pick one which is appropriate for your app. That page also has excellent guidance for when to use each type of tile.

The Hub Page

If your app has a number of different options, different categories of content, or has multiple projects the user may be working in, a hub page may make sense. A hub page is the first page the user sees - it provides an overview of what has been done so far, and what remains to be done, as well as what new content is available and more. The minesweeper screenshot near the start of this post is an example of a hub page. It lets you switch themes, see your achievements, and more.

Many productivity apps on the desktop include a dialog which is displayed when you first start the app. For example, when I open Cubase 7, I get this dialog:

Formatted another way, this type of hub would be perfect for the hub screen of a Windows 8 app.

Similarly, when I open Premiere Pro and After Effects, I get these screens:

And, of course, you're all familiar with the hub screen we see almost every day:

If your app is complex enough to warrant it, or simply needs a nice landing spot for the user before throwing them into the task, consider putting a hub page. It will help you with discoverability of features for your app, as well as make it easy for a new user to navigate your UI.

Music Maker Jam uses its hub page for selling content packs as well as for loading existing projects and even a little advertising on the side.

One of my favorite uses of a hub screen is in the episode-based game Adera, shown here in a screen shot from my Surface. Notice how it has the main tasks right there, but then additional engaging information to the right, including achievements and collections. Each group lets you drill down to see more episodes, items, and more.

A good tile can attract the user's attention, and a good hub screen can engage them them moment they launch your app.

Test, Test, Test

Finally, I can't say this enough: test your app. Test it on your own machines, and then, if you don't have a formal testing group, send side load versions to your friends to test. At a minimum, you want to test on all processor architectures you support (x86 32, 64 and ARM). If your app makes use of peripherals like sound cards, web cams, microphones, or others, you'll want to test using a variety of those devices as well.

Trust me, you don't want your app to earn one of these stickers:

Just because an App seems smaller than an Application, don't test it any less.

In the next post, I'll provide some ideas for promoting your app and for getting your user to get past the first hurdle: the initial download.

Maker Geek Roundup 017 for 1/22/2013

Pete Brown — Tue, 22 Jan 2013 04:14:21 GMT

This fall I was swamped with my new position at work, all the awesome Windows 8 launch work, plus my involvement in Build 2012, so I took a break from the roundup. Lots of stuff to cover here.

3d Printing, CAD/CAM/CNC

Printing Lumia Cases (based on templates Nokia themselves released | Rob Miles)
- and Nokia Releases 3D Printing Templates for Lumia 820 Shells; Allows You To Print Your Own Custom Shell
MakerBot Replicator™ 2X Desktop 3D Printer (MakerBot - Announced at CES)
- Announcing the MakerBot Replicator 2X Experimental 3D Printer!
Cubify - Express Yourself in 3D (CubeX - Announced at CES)
Will 3D Printing Be Legislated (3d Printers Australia)
The Largest Ever 3D Printed Wrench! (YouTube | Objet)
Ultimaker pivotal in Dutch medical research (Ultimaker)
3D Printed iPhone Case with Moving Gears! (YouTube | Objet)
Design Unique Things Easily With MakerBot Customizer (Makerbot)
Mendel90 updates (HydraRaptor)
Bringing a 12 year old Roland MDX-20 up to date (Johan von Konow)

Laser Cutting

Laser cut gingerbread house (Johan von Konow)
Laser cut layers (Ponoko)
Laser Cut Paper Stained Glass Windows (Ponoko)

NETMF (.NET Gadgeteer and Netduino)

How to get our Netduino running faster (Highfield Tales)
Playing with Mountaineer Ethernet Mainboard (Marco Minerva)
Modbus libraries version 2 beta are out! (Highfield Tales)
Rick Dangerous Port for NETMF | Take a break (Valentin Ivanov)
Gadgeteer Home Automation System (Marco Minerva)
Creating an UDP Server with .NET Gadgeteer (Marco Minerva)
Netduino 2 - Faster & Better for the Same Price. (Make)
Netduino - Optocoupler testing (My projects)
Netduino Day 3 - Multiplexed Seven-Segment LED displays (Embedded Lab)

Arduino and AVR

Nanino - the DIY friendly Arduino (Johan von Konow)
An Arduino-based ADB-to-USB adapter for NeXT keyboards (Arduino Blog)
An Arduino-controlled RGB lamp (Arduino Blog)
RFID Multipass spoof using ATTiny85 (Dangerous Prototypes)
Cracking an electronic safe using brute force (Hack-a-day forum)

Other Microcontrollers (PIC, ARM, Raspberry PI, Parallax, more)

Snake game on an ARM microcontroller (Jumptuck)
Hive retro computer (Dangerous Prototypes | Classic computer created with Parallax processors)
(Also see Launchpad + Rapsberry PI link under synthesizers/MIDI/OSC)
Macro Pi - Focus Stacking using Raspberry Pi (David Hunt Photography)
Raspberry Pi with RGB-Pixels and node.js (Tinkerlog)

General Electronics and Hardware Hacking

An example of an hardware problem and how to solve it (Highfield Tales)
Quick Tip - Soldering Resistors to LEDs (Ian Lee)
Analog Clock turned DC Voltmeter (WhiskeyTangoHotel)
Oh Sting, Where Art Thou Wifi? (Jomegat)
Make a Variable Resistor with 1 Million Settings (Instructables)

Robots, *Copters, and Robotics Studio

Reverse Engineering the Propel ExecuHeli IR Protocol (PetaVolt)
Make: Lego and Arduino Projects Foreword (Robotgrrl)

General Maker

A Desktop Computer For The Ages (Retro Thing)
Combat Shotgun, Fallout (Volpin Props)
Princess Wands (Ian Lee)
- plus: Birthday Badges
Daft Punk Helmet (Thomas): Part 1 (Volpin Props)
Heat Sensitive Table (Toxel)
Skyrim Female Ancient Nord Helmet (Volpin Props)
Real-life Mario Kart with RFID-Tagged Special Items (Make)

Synthesizers, Music, and MIDI/OSC

NEW! AtomoSynth MochikaXL v2.2 "Dark side" (Atomosynth)
The Monster: DIY Project Looks, And Sounds, Like Alien Spacecraft Control Panel (Create Digital Music)
Launchpad + Raspberry Pi (Illuminated Sounds)
Midi Fighter Spectra: Crazy-Sexy Arcade Buttons, US$175.99 [Live+Serato+Traktor] (Create Digital Music)
Moog Sub Phatty Synthesizer Sets New Standard for Analog Sound Design (Moog, introduced at CES)

Retro Computing and Commodore!

(see the "The Monster" link under synthesizers for some C64 + SID action!)
Portable Commodore 64 Turns 30 (Retro Thing)
The 6502 CPU's overflow flag explained at the silicon level (Ken Shirriff)
Strange peripherals… the Triton Quick Disk (MOS6502)
Strange peripherals… the Soft Card (MOS6502)
Macintosh Plus (Nice refurb | My DIY Blog)
Sub Hunter Cartridge Available! (C64) (RGCD)
Let me carry your C64 (MOS6502)
There and back again (MOS6502)
Space Lords (Centaurus) Available! (C64) (RGCD)

Random stuff

You Built What?!: The World's Fastest Baby Carriage (Popular Science)
Bet you didn't do this well when you last TP'd a house (Toxel)

Traits of a good Windows Store app privacy policy

Pete Brown — Mon, 21 Jan 2013 20:39:03 GMT

A common cause of Windows Store app certification failures is a missing or insufficient privacy policy. Many don't realize that a network-enabled app must have a policy, or if they do, don't realize exactly what needs to go into it. In this post, I'll talk about some of my observations regarding what makes for a good privacy policy for a Windows Store app.

IMPORTANT: This is neither official guidance from Microsoft, nor legal advice from me. I'm not a lawyer - not even close. Privacy policies are legal documents like licenses and should be crafted by a lawyer. When you speak to your lawyer, however, you'll be better prepared because of the information below. These are simply my suggestions based upon what I have observed. I do not guarantee that a privacy policy written as I recommend will pass store certification or be an appropriate legal document. (Hopefully that's enough disclaimer.)

Also, I am not on the Windows Store certification team. Please don't come to me with "App X's privacy policy doesn't seem to follow your instructions but it got in and I didn't" type of questions. For those types of questions, there is the "Resolving certification errors" page http://aka.ms/StoreFix and the Windows Store support site http://aka.ms/StoreSupport . Also, for obvious legal reasons, I cannot review your privacy policy and provide you with feedback on it.

Yes, the disclaimer is pretty big, but there's good reason behind that. If you dig into the certification requirements, you'll see that we don't recommend a privacy policy or provide any templates for one, despite it being a fairly common request. That's because Microsoft is not able to give legal advice and, as I mentioned above, the privacy policy is a legal document.

You should use a lawyer to help you write your privacy policy. In reality, though, I know most independent developers will not request the services of a lawyer, so let's talk a bit about what should go into that policy regardless.

First, please review these requirements (specifically requirement 4.1/4.1.1). The requirements are updated quite often to remove ambiguities and provide further guidance, so if you see any conflicts between what I'm writing here and what's in those requirements, the requirements rule. The other important page is the Resolving certification errors page which also includes information on the privacy policy.

What is a privacy policy?

In the context of a Windows Store app, a privacy policy is a legal document which details any privacy related aspects of the app. It's intended to be transparent to the user and to allow them to make informed decisions about what they share with the app, and even if they want to install it to begin with.

ASIDE: When writing your policy, consider not only how to explain the privacy aspects of the app, but also whether the app even needs to the things it is using. For example, does the server really need to store locale information about the user? If not, go back to the app development team and request they not keep that around. Your privacy and other legal obligations get simpler the less you store. If you don't absolutely need it, don't store it.

How to create a good privacy policy

A good privacy policy is clear, concise, and complete. It tells the user exactly what is captured and what the app does it with. It gives the user instructions to follow if they don't agree with aspects of the policy (even if those instructions are to uninstall the app and then email us at XYZ to delete the persisted data).

Make it specific

Many privacy policies fail in certification because the policy isn't specific to the app. In most cases, the linked policy is a generic one which is available on the company's web site. I personally prefer to see a separate privacy policy just for the app, but if that's not possible, you at least need to make sure the policy has a section which very specifically details the named Windows 8 app, what it collects, etc.

Any app-specific section should have its heading on-screen, without scrolling, when displayed at 1366x768 on a PC. In this way, an end user will more easily find the content and what an end-user can more easily find, so can a certification tester.

Make it comprehensive

The privacy policy needs to detail every piece of information that is captured, and what you do with it. For example:

IP Address
Device ID
User name from Windows
Language information
Third-party account information
Webcam? Microphone?
Documents?
Contact information?
Information collected by ads? (link to privacy policy for the ad network)
etc.

If any of those things are transmitted (IP address always is), then you need to say what you do with it. For example, you may point out that your server keeps a log of IP addresses which contact the service, but that this information is not given to third parties, is purged every X days (if it is), and would not be released to any third parties except when required by law. You must

Explain what is collected
Tell your users how it is used, stored, secured, and (if so) disclosed
Provide a way for the user to control the information
Explain how users can access the information you've collected
Follow the law.

Although it is rare, if you don't collect or store anything, just say so in your policy (for example, a peer-to-peer networking app which stores nothing, not even the IP addresses, so server logs don't even come into play). You still need to have a privacy policy if you declare the Internet Client, Internet Client/Server or Private Network Client/Server capabilities.

Make it comprehensible

Legal language is generally seen as pretty opaque to common English readers. The language serves a good purpose, however, in that the words chosen typically have well-understood legal definitions and therefore help remove ambiguity. A common mistake I've seen with EULAs and similar in the past, is a lay person writes them using what they think looks like legal language. The end results is often both incorrect and incomprehensible. To a lawyer, it sticks out like web page code written by that spreadsheet guru in the accounting department does to you.

A privacy policy does not necessarily have to be written in legalese. (Your lawyer can help you make this distinction if necessary). In fact, I much prefer privacy policies that are short and understandable and written in common language. If you are not a lawyer, and are writing your policy yourself, just write it in plain English (or the appropriate primary language for your app) and don't pretend to be a legal expert.

Make it honest

Be honest about what you collect and what you do with it. If there's anything which is even remotely a gray area, explicitly call it out in the policy.

If you update the privacy policy, include a revision date at the top and then link to any previous versions. In general, unless you've made the user opt in to a newer version of the policy, the one that is in effect is the one that was out there when they purchased the app. If there's any doubt, contact a lawyer for how to proceed with revisions. Just don't try to slip them in there with no notice.

Don't be mean or sneaky. It will catch up with you.

Make it available

The privacy policy is linked to from the description page of your Windows Store app listing, as well as from the charms bar while the app is running. I'd also encourage you to make it available as a link from your web site's standard privacy policy.

You can link to a web page with the privacy policy, or simply include it in-line. I prefer to read it right on the screen, much like the eBay app does, but either approach can be valid. Here's the eBay app showing all of the points I've discussed so far.

I believe their policy is simply in an IFrame or webview in the flyout. In that way, it is made available inside the app as well as online.

There are many other aspects of a good privacy policy, but these were the ones that really stood out to me. Please consider them when creating your own apps. Most of all, consider your user and what is appropriate for them and fair to them. Put the user in control of their data and their privacy, and don't make it difficult for them to opt-out.

A simple bitcrusher and sample rate reducer in C++ for a Windows Store App

Pete Brown — Mon, 14 Jan 2013 00:10:45 GMT

I'm working on a Windows 8 synthesizer app using XAudio2 and a C++ + DirectX/XAML Windows Store app for Windows 8. As part of this, I thought it would be fun to add a simple bit crusher effect with included sample rate reducer. The point of this effect is to make samples sound like they came from older machines with lower bitrates and sample depth. To do that, I had to do two things to the samples:

1. Reduce the bit depth of the samples. This would control vertical stepping as with a traditional bitcrusher.

2. Reduce the bit rate of the samples. By default, this is 44100 or 48000 samples per second. Older systems did quite a bit less, often 8192 samples, sometimes fewer like 4096 or 8192. I want to get that old low-fi vibe as simply as possible.

I'm not plugging into the XAudio2 effects pipeline or otherwise using any XAudio2 plumbing for the bit crusher effect here. The algorithm would be given a buffer of stereo samples to process. The buffer size will eventually be based on performance, but right now, I just have a looping sample buffer. If you want to learn how to create your own audio using XAudio2, please refer to my older post on this topic (take care to notice the comment at the bottom where I pointed out that I didn't initialize one of the values).

I'm not presenting a complete project here, but will post enough source for you to have context for what I'm doing.

The StereoSample Structure

Each sample is actually a stereo pair. Stereo oscillators? How cool :)

struct StereoSample

{

public:

    SAMPLE_t Left;

    SAMPLE_t Right;

};

SAMPLE_t is defined as float.

The Voice Class

The voice class represents a single voice in the synthesizer. Among other things, it includes a collection of oscillators. Right now, all three oscillators are configured to output exactly the same thing. The Render function handles that output as well as plugging in the bit crusher effect. Note that I apply the effect to the output from all three oscillators, but in the real synth, this is decoupled so I could apply it to a single oscillator in a single voice.

Voice::Voice(IXAudio2* audioEngine, int stereoBufferSize) :

    _audioEngine(audioEngine),

    _stereoBufferSize(stereoBufferSize)

{

    _bufferData = new StereoSample[stereoBufferSize];



    for (int i = 0; i < MAX_OSCILLATORS; i++)

    {

        _oscillators.push_back(shared_ptr<Oscillator>(new Oscillator()));

    }



    // set up wave format using my good friend WAVEFORMATEX

    WAVEFORMATEX wfx;

    wfx.wBitsPerSample = SAMPLE_BITS;

    wfx.nAvgBytesPerSec = SAMPLE_RATE * SAMPLE_CHANNELS * SAMPLE_BITS / 8;

    wfx.nChannels = SAMPLE_CHANNELS;

    wfx.nBlockAlign = SAMPLE_CHANNELS * SAMPLE_BITS / 8;

    wfx.wFormatTag = WAVE_FORMAT_IEEE_FLOAT; // or could use WAVE_FORMAT_PCM

    wfx.nSamplesPerSec = SAMPLE_RATE;

    wfx.cbSize = 0;    // set to zero for PCM or IEEE float



    DX::ThrowIfFailed(_audioEngine->CreateSourceVoice(

        &_xavoice,

        (WAVEFORMATEX*)&wfx,

        0,

        XAUDIO2_DEFAULT_FREQ_RATIO,

        reinterpret_cast<IXAudio2VoiceCallback*>(&_voiceCallbackHandler),

        nullptr,

        nullptr));

}











void Voice::Render(long phase, float noteFrequency)

{

    XAUDIO2_BUFFER buffer;



    //int byteCount = sizeof(SAMPLE_t) * 2 * _stereoBufferSize;

    int byteCount =  sizeof(StereoSample) * _stereoBufferSize;



    // zero all buffer data

    memset((byte*)_bufferData, 0, byteCount);



    //_oscillators[0]->Render(phase, noteFrequency, _bufferData, _stereoBufferSize);

    vector<shared_ptr<Oscillator>>::const_iterator cii;

    for (cii = _oscillators.begin(); cii < _oscillators.end(); cii++)

    {

        (*cii)->Render(phase, noteFrequency, _bufferData, _stereoBufferSize);

    }



    // TEMP! Bit crunching to try out audio processing

    BitCruncher cruncher;

    cruncher.BitDepth = 24;

    cruncher.BitRate = 2048;



    cruncher.ProcessSampleBuffer(phase, noteFrequency, _bufferData, _stereoBufferSize);



    // TEMP Looping

    // the buffer will be looped infinitely

    buffer.AudioBytes = byteCount;

    buffer.PlayBegin = 0;

    buffer.PlayLength = 0;    // play entire buffer

    buffer.LoopBegin = 0;

    buffer.LoopLength = 0;    // loop entire buffer

    buffer.LoopCount = XAUDIO2_LOOP_INFINITE;

    buffer.pAudioData = (const BYTE *)_bufferData;

    buffer.pContext = NULL;

    buffer.Flags = 0;         // this is the value I left out in the previous post



    // wire up the buffer

    DX::ThrowIfFailed(_xavoice->SubmitSourceBuffer(&buffer));



    // start playing sound.

    DX::ThrowIfFailed(_xavoice->Start(0));

}

My C++ isn't great yet, but I'm learning. I've even learned the shared_ptr and vector templates :)

The Oscillators

The oscillators have a lot more to them, but the render functions are the core:

void Oscillator::RenderSine(long initialPhaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount)

{

    // fill the buffer

    for (int i = 0; i < bufferCount; i++)

    {

        float sample = (sin((i + initialPhaseIncrement) * 2 * PI * noteFrequency / SAMPLE_RATE));



        // left audio or mono

        buffer->Left += sample * this->_volume;



        // right audio

        buffer->Right += sample * this->_volume;



        buffer++;

    }

}

Volume is per-oscillator. Panning etc. is not implemented in this listing. I have different render functions for each type of waveform. They are switched using a function template to point to the current render function. Thanks to everyone on Twitter last night (especially Jeremiah Morrill) for helping me sort out how to use the std::function type.

RenderFunction = std::bind<void>(

    &Oscillator::RenderSine,    // function pointer

    this,                        // implicit this

    std::placeholders::_1,        // initialPhaseIncrement

    std::placeholders::_2,        // noteFrequency

    std::placeholders::_3,        // buffer

    std::placeholders::_4);        // bufferCount

The entries in the Oscillator's class definition therefore look like this:

void RenderSine(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderPulse(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderTriangle(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderSawtooth(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderRamp(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderMultiSaw(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

void RenderNoise(long phaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);



typedef std::function<void(long, float, StereoSample*, const long)> RenderFunction_t;

RenderFunction_t RenderFunction;

The magic part is the std::function. (Aside: searching for "std::anything" will get you a nice selection of STD testing ads in the search engine sidebar).

Now, just because it sounds so good with the bit crusher, here's my noise implementation:

void Oscillator::RenderNoise(long initialPhaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount)

{

    std::uniform_real_distribution<float> dist(-1.0f * _volume, 1.0f * _volume);



    for (int i = 0; i < bufferCount; i++)

    {

        float sample = dist(_randomGenerator);



        buffer->Left = sample;

        buffer->Right = sample;

   

        buffer++;

    }

}

For that to work, you'll need to initialize the random number generator elsewhere in the code. I do it in the constructor:

Oscillator::Oscillator(void)

    : _randomGenerator(std::time(0))

{

    _volume = DEFAULT_OSCILLATOR_VOLUME;



    _pan = 0.0f;



    RenderFunction = std::bind<void>(

        &Oscillator::RenderSine,    // function pointer change to render function you want

        this,                        // implicit this

        std::placeholders::_1,        // initialPhaseIncrement

        std::placeholders::_2,        // noteFrequency

        std::placeholders::_3,        // buffer

        std::placeholders::_4);        // bufferCount

}

The Bit Crusher/Cruncher

This simple class is the real point of this post. Here's the class's header file. I call it "BitCruncher" because it does bit crushing plus sample rate reduction.

#pragma once



class BitCruncher

{

public:

    int BitRate;        // for reducing the sample rate

    int BitDepth;        // for quantizing the sample values, for example, to make them 8 bit



    BitCruncher(void);

    ~BitCruncher(void);



    void ProcessSampleBuffer(long initialPhaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount);

};

And here's the implementation. Details after the listing.

#include "pch.h"

#include "BitCruncher.h"

#include <cmath>



BitCruncher::BitCruncher(void) :

    BitDepth(4),

    BitRate(4096)

{

}





BitCruncher::~BitCruncher(void)

{

}





#define ROUND(f) ((float)((f > 0.0) ? floor(f + 0.5) : ceil(f - 0.5)))



void BitCruncher::ProcessSampleBuffer(long initialPhaseIncrement, float noteFrequency, StereoSample* buffer, long bufferCount)

{

    int max = pow(2, BitDepth) - 1;

    int step = SAMPLE_RATE / BitRate;



    int i = 0;

    while (i < bufferCount)

    {

        float leftFirstSample = ROUND((buffer->Left + 1.0) * max) / max - 1.0;

        float rightFirstSample = ROUND((buffer->Right + 1.0) * max) / max - 1.0;



        // this loop causes us to simulate a down-sample to a lower sample rate

        for (int j = 0; j < step && i < bufferCount; j++)

        {

            buffer->Left = leftFirstSample;

            buffer->Right = rightFirstSample;



            // move on

            buffer++;

            i++;

        }

    }

}

For reducing the bit rate, the current algorithm is like a sample and hold. It takes the first sample and holds it for however many steps it needs to. In fact, on my modular synth, if I patch an oscillator into the sample and hold unit, I can get pretty much the same result.

Note that this happens per-oscillator. Each voice has multiple oscillators each of which may or may not be crushed, so I don't simply submit a low bitrate buffer to XAudio2 and let it do the expansion. I'm also working on a couple other algorithms in addition to the current.

The bit depth reduction is handled by the round statements. Floating point samples are in the range of -1.0 to +1.0. I first calculate the maximum number for the specified bit depth (first statement with pow). Then, I add 1.0 to the sample to get it into the range of 0..2.0. I then map that 0..2.0 to the "max" value (which is 0..max"). Then, dividing by "max" I get back a now rounded value in the range or 0..2.0, with at most "max" unique possible values. Finally, I subtract 1.0 to get back in the range of -1.0 to +1.0.

UPDATE: @c64_gio on twitter sent me some really great tips for how I can improve this code. I especially like the iteration approach and use of vectors instead of raw bytes. You can see some of his comments here: http://pastebin.com/Q8HqHRDd.

This algorithm appears to work, so let's take a look at the results.

Results

I hooked up my Rigol to the main output of my sound card (a MOTU 828mk3) to take a look at the generated waveforms.

What follows are the configurations set on the BitCruncher class and a photo of the resulting wave forms.

BitDepth 24, BitRate, 44100. This is about as good as it gets in terms of the scope's resolution.

BitDepth 24, BitRate 8192 (very slight stepping)

(note that the frequency is warbling a bit between 110 and 220. I think my Rigol is confused, possibly due to me not completing cycles in the buffer)

BitDepth 24, BitRate 4096 (more stepping)

BitDepth 24, BitRate 2048 (a whole lot of stepping). This sounds like a sine wave with whistling harmonics over it. It reminds me (only louder) of the overtones from some 8 bit synth chips from 80's computers.

I believe this one was BitDepth 4 and BitRate 44100. Notice the flats at the peaks. This is due to rounding and contributes a square-wave overtone to the sound.

BitDepth 2, BitRate 2048 (this sounds much more like a square wave). This one had a fair bit of jitter to it, presumably because 44100 is not evenly divisible by 2048, and for the final output, I'm simply looping a buffer of 44100 * 5 seconds.

The bitrate reduction is especially interesting when applied to white noise. You totally get the Atari/C64 vibe from it.

As I do other interesting things with this synthesizer project, which will hopefully be in the Windows Store when I complete it, I'll continue to post about them here.

No downloadable source code for this project.

Installing Unsigned Drivers on Windows 8 64 bit (or: how to get STM ST-Link working)

Pete Brown — Mon, 07 Jan 2013 22:40:44 GMT

I recently did some work on my MikroElektronika ARM development board. This was the first time I fired up the board on my Windows 8 system. Everything in the IDE worked fine until I tried to do some deploying and debugging on the board itself. It was then that I realized the board's driver wasn't correctly installed. I looked in the device manager and, sure enough, the board had the little exclamation point next to it. It was recognized, just not available.

The first thing I did was reinstall the driver using the Mikroelektronika installer. Everything appeared to work, but the driver never actually installed. In fact, the directly the installer created was empty.

I install a lot of really strange hardware the average user will never see. Because of that, I've noticed a number of device driver installers not handling failure at all - they simply complete and return "success" regardless of what happens. People, fix your installers!

So, I unpacked the driver installer and tried to manually install it. Windows then told me it couldn't install the driver because it's unsigned. Aha!

With Windows 7, we started requiring all 64 bit drivers to be signed. Before that, it was a recommendation. With Windows 7, however, it was relatively easy for a power user to bypass this requirement and install unsigned drivers. With Windows 8, we've raised the bar to help make sure manufacturers only give you trusted, verified code. This helps prevent malicious folks from offering you drivers. (How many times have you searched for a driver and found 300 shady-looking sites that purport to have the driver? Yeah, like I'd install that.)

Now, that said, there are still some manufacturers who haven't yet signed their drivers. For those, this post will describe how to install anyway. Again, this is a workaround for the OEM not properly signing stuff. You should only run into this when testing beta stuff for them. If you run into it with production drivers, let the OEM know.

Rebooting in Advanced Mode

With previous versions of Windows, the advanced startup options required you to press a function key as the computer is booting. With Windows 8 and UFE boot, the boot (especially on a machine with a fast SSD), boot time is just too short to be able to press that key. Instead, Windows 8 handles the advanced boot from within Windows. One of the advanced boot options is the one to let you install unsigned drivers.

For me, the easiest way to get to the advanced boot menu is to shut down from the command prompt. Using Windows + X (or right-click the bottom left of the screen), get the power user menu. From that menu, choose "Command Prompt (Admin)" as shown here:

Then, at the administrator command prompt, type shutdown /r /o. The /r is for reboot, the /o is for the advanced boot options.

Now, I can't screenshot the advanced boot menu on this PC without a remote desktop session or something. Windows + Print Screen doesn't work there. So, here's the progression.

First, Windows will prompt you asking for what kind of action you want to take. Select the following:

Troubleshoot
Then Advanced Options
Then Startup Settings

Then press the restart button. Your PC will then reboot. Once it reboots, you'll get the Advanced Startup Options menu. From that, you want to pick the "Disable driver signature enforcement" option. On my desktop machine, that is #7.

Windows will then boot normally, but with the option in place.

Installing the unsigned driver

Once you pick the option to allow unsigned drivers, then you can perform the installation as usual (using the installer or the .inf). Don't worry, it'll stick around after another reboot - it's not a safe mode, just a lifting of a restriction.

You'll still receive a warning, but this time, you get the option to perform the install anyway.

As long as you are sure the driver is from a trusted publisher, and that you're using the latest driver, go ahead and install it. If you are unsure at this point, then unsigned driver installs are not for you.

Once I did this, my STLink programmer (that's what the MikroElektronika programmer shows up as) showed up just fine, and began working:

That's all there is to it.

If you run into this, I highly encourage you to inform the OEM about the unsigned driver issue, and encourage them to sign their driver. If they then release a properly signed version, be sure to update directly to that so you no longer have any exceptions to the driver policy on your machine. This will certainly make future updates smoother for you.

Also, there are "tips" out there to permanently enable the advanced boot options. I discourage you from using this on a day-to-day machine as it will both promote bad practices and also make your boot time that much longer.

A MIDI clock pulse to analog sync voltage converter

Pete Brown — Tue, 01 Jan 2013 00:10:22 GMT

I have a few pieces of analog gear which either don't support MIDI, or simply work better with voltage control. This makes including them in a sequence difficult as timing of arpeggios or sequences will drift away from the rest of the performance. Not to mention that synchronizing them by ear is not a simple task in any case, and impossible to do in real-time if you want to adjust the tempo during the performance.

One such piece is my little Korg Monotribe. This is a combination drum machine and step sequencer built into a very inexpensive package.

The Monotribe doesn't have MIDI support (although you can build a conversion for MIDI), but it does accept a sync pulse. The Aturia Minibrute doesn't send an analog clock pulse, so there was no way to synchronize the two. However, the Minibrute *does* accept MIDI clock pulses from an external source, so I knew I could build on that.

Hybrid Analog/Digital sequencers like the Doepfer Dark Time will handle this synchronization for you, but for a price. I already have one analog sequencer on order, one small one mostly built, and another ready to be built, so I didn't want a third one right now.

The Goal

So the goal is to drive both analog gear as well as more modern MIDI gear from an external MIDI clock. In my case, I decided to use Cubase 7 on my PC as the clock source. The completed setup looks like this:

All the straight MIDI communication just works. The rest of this post will focus on the development of the MIDI to analog sync signal part. First, however, a little background on synchronization.

MIDI sync

MIDI master clocks send out 8 bit synchronization messages at the rate of 24 for every quarter note. At a typical BPM of 120, that means that there are 24 * 120 = 2880 clock messages per minute, or 48 clock messages per second.

The standard MIDI protocol itself is a 5v serial protocol running at 31,250 bits per second with 8 data bits, no parity bits, and 1 stop bit. Most messages are two or three bytes in length, but a number of important messages, such as the real-time messages, are only one byte in length. Also note that messages can be interrupted by real-time messages. So, you could get the "note on" message, and then the clock byte, and then the note on message's data. Any code which parses these messages must handle this gracefully.

Analog Sync

Analog sync pre-dates MIDI clock signals, so there are a number of standards. Roland used a DIN sync for drum machines, TB-303, and others. This is a 5 pin cable which looks like MIDI, but is actually carrying completely different analog signals.

Even older than that is the modular approach of clock pulses. This is typically a 5v square pulse which is used to move a sequencer to the next step. This is the way most analog sequencers synchronize with each other, all sharing a common clock/sync source.

The Korg monotribe is a new design, but follows older analog principles. In this case, the sync signal doesn't need to be 5v. In fact, there are phone apps which use audio level signals from the headphone jack to generate sync pulses for the monotribe. Much like the classic analog approach, the monotribe sync approach is used to move the sequencer from one step to the next.

There are many other devices which can synchronize with signals like this. For example, the Nova Drone drone synth includes LFO sync which should work with this type of signal. (I haven't tried it yet, though).

(Yes, that's a Cthulhu mug. I know I just floored you with the awesomeness of this photo)

Implementation

I've done a fair bit with MIDI hardware, so I knew generally how to parse messages and otherwise deal with the data. I also have a MIDI module which, although designed for .NET Gadgeteer, includes pins so I can use it with any microcontroller. Real-time processing of MIDI messages like this has proven to be too intense for interpreted code like NETMF, so I turned to my ARM development board. Sure, this is something which could have been easily accomplished on Arduino, but I've been getting into ARM lately, and have had larger plans for the processor.

The development board I used is my Mikroelektronika EasyMX Pro v7 for STM32. the C IDE is a mess compared to Visual Studio, but I can't praise this board enough. It's super easy to develop and debug on it, all over USB.

Because the monotribe runs perfectly fine on low amplitude pulses, the 3.3v signal level from the ARM processor works fine. If you use this approach with other analog gear, you'll likely need to scale the output up to 5v (again, not an issue if you use classic Arduino or AVR which both natively support 5v signals).

Initially, I based the pulses on 64 for some reason. I originally thought MIDI used 64 pulses and not 24. Because of this, the code below is not quite correct (it works, but doesn't correspond to actual beats, so the divisions aren't as useful as they should be).

#define MIDI_TIMING_CLOCK 0xF8

#define ANALOG_CLOCK_PULSE_DURATION_MS 1

#define MAX_TICKS 64;



// USART2 TX is PA2

// USART2 RX is PA3



#define GPIO_BASE           GPIOD_BASE

#define ODR                 GPIOD_ODR



#define SetAllPinsLow()     ODR = 0;

#define SetPins(pinMask)    ODR = pinMask



char _uartReadByte;



void main() {

    unsigned short currentTick = 0;

    unsigned short pinsHigh = 0;



    GPIO_Digital_Output(&GPIO_BASE, _GPIO_PINMASK_LOW); // Set pins as digital output



    UART2_Init_Advanced(31250, _UART_8_BIT_DATA, _UART_NOPARITY, _UART_ONE_STOPBIT, &_GPIO_MODULE_USART2_PA23);



    Delay_ms(100);                  // Wait for UART module to stabilize



    while (1) {

      if (UART2_Data_Ready()) {

         _uartReadByte = UART2_Read();     // read the received byte

    

         if (_uartReadByte == MIDI_TIMING_CLOCK) {           // if MIDI clock message

       

            pinsHigh=1;    // always output full clock on first pin

          

            if (currentTick % 2 == 0) {

               pinsHigh |= (1 << 1);

             

               if (currentTick % 4 == 0) {

                  pinsHigh |= (1 << 2);

                

                  if (currentTick % 8 == 0) {

                     pinsHigh |= (1 << 3);

                   

                     if (currentTick % 16 == 0) {

                        pinsHigh |= (1 << 4);

                      

                        if (currentTick % 32 == 0) {

                           pinsHigh |= (1 << 5);

                         

                           if (currentTick % 64 == 0) {

                              pinsHigh |= (1 << 6);

                           }

                        }

                     }

                  }

               }

            }



            if (pinsHigh) {

               SetPins(pinsHigh);

             

               Delay_ms(ANALOG_CLOCK_PULSE_DURATION_MS);

          

               SetAllPinsLow();

             

               pinsHigh = 0;

            }



            currentTick = (currentTick + 1) % MAX_TICKS;

         }



      }

    }

}

I hate that K&R style of brace indentation, but like I said, the IDE is a mess. If you deviate from that style of indentation, the tabs and whatnot get really screwed up. In fact, they get a little screwed up anyway. IDEs in the microcontroller world are a long way from what we're used to for more mainstream development.

Essentially, the code gets each incoming byte and checks to see if it is a clock message. If so, it checks the current tick to see where we are in the timing and then sets a bitmask to set the pins on a port to high based on that step. It then sets the pins high, sleeps for 1ms, then sets them low again.

When I ran the code, I looked at the pulses using my Saleae Logic 8 channel USB logic analyzer (something which is absolutely indispensible for work like this) and, after some debugging, got the right results:

When you code this low to the metal, timing can be really spot on. I love that!

Here's the full device setup on my mess of a desk:

And here's a full set of timing pulses, without the MIDI clock signal visible:

You can see that each row has a period twice that of the row above it. By connecting to different signal divisions, you can speed up or slow down the slave sequencer, but still keep it in time with the rest of the performance. (Remember, I need to change it to be based on 24, not 64 clocks per quarter note)

What's Next?

I'm going to correct the timing and then develop an inexpensive board around this, possibly including support for TB-303/x0xb0x style DIN sync (including stop/start) in addition to the analog sync. I'll keep a couple around for my studio, but have others for sale. If you're interested, drop me a line via the contact link here and let me know.

I'll also post a recording of the sync working on my Soundcloud page.

Update: Recording is here: https://soundcloud.com/psychlist1972/monotribe-and-modular-sync-test

The importance of app submission notes in the Windows Store

Pete Brown — Mon, 10 Dec 2012 18:19:13 GMT

Windows Store apps go through both automated tests and human testing. The automated testing uses a process similar to what you use on the client in the form of the WACK tool. This tool verifies the basics: does it crash? does it have the right images? does it spin up in time? etc.

No one likes to waste time by going through the submission and certification process multiple times. Many apps also require additional credentials or specific information that users of the apps would normally have access to. This is one spot where we see rejections that could be very easily avoided.

When submitting apps to the Windows Store there is a section titled "Notes to testers". This section is absolutely crucial to help ensure your app makes it through certification testing. In it, you need to provide:

Usage notes if the app's usage isn't obvious (also: reconsider your UI if this is the case)
Every userid/password required in the app. For example, I recently saw an app where the initial login information was provided, but the user needed a PIN to access an account beyond that. You need to have test accounts set up for every part of the app, and provide the information required to access them.
Every piece of crucial test data to make it through a scenario. (For example: if a phone number must be in a particular set of area/country codes, provide that information)
Ideally, don't make the tester create a new account. Give them login credentials for a dedicated dummy account, pre-populated with test data.

Remember, humans read the instructions. If you're unsure what information is needed, give the app to a friend who has never used your app (or the back-end services it uses) and ask them to go through each page. Write down everything they ask you to provide, and then include that in the notes.

For more information on submitting your apps to the store, see the App submission checklist on MSDN.

A windows 8 trick: Protocol activation of apps (and the nick app)

Pete Brown — Wed, 05 Dec 2012 19:45:54 GMT

I have a four year old girl and an almost seven year old boy. From time to time, my son will play games on the nick jr web site, or watch a video.

Nick has a portal-style app for Windows 8. This app provides access to videos and photos, as well as links out to games. Notice how even on my low DPI 30" screen, the tiles are large and everything is nicely scaled on the hub page. I've seen apps which have just a tiny bit of the screen filled, and that makes me sad -- this is a better implementation for almost zero extra effort.

That bit of green slime at the top? Besides being a classic Nickelodeon item, it's also something which invites you to click/touch. (Well, it does to a kid anyway.) What happens when you click it? It displays the navigation app bar. Pretty clever.

One of the Nickelodeon properties my kids both like is SpongeBob SquarePants. He has his own second level hub page as shown here.

Everything is appropriately branded, and kid-friendly (assuming you consider spongebob "kid-friendly". I know opinions differ there). This may at first seem like a typical "bunch of boxes" app, but it does it in a way which is appropriate to the properties and audience.

When you click on a video, it plays directly in the app, full screen.

Winx club is another interesting property for Nickelodeon, and another that my kids both like. It's a bit like Disney Fairies meet Bratz or Monster High or something else I've seen in that aisle at the store during Christmas shopping.

As with SpongeBob, the video player is inline. The overlays are there only for a second or two and only if you move the mouse or touch the screen. The fairy with the red hair is actually pleased to get that gift, but I think she's too cool to show it ;)

So, overall, a typical media portal experience target to kids. It's simple and well-done.

Games and the browser

What's really interesting to me is what happens when you launch a game. Nickelodeon didn't port their games to Windows 8, but instead decided to leverage their existing games and launch them in the browser, directly from the app. The upside to this is the obvious savings in effort. The downside is that the game is really tiny on my giant screen. In their defense, it's rare to find a child with a 30" screen running at 256ox1600 :). On a smaller screen, it looks just fine, but I'd like to see them do a little scaling in a future update.

When the nick app launches the game, this is an example of the URL they use:
http://www.nick.com/games/nickapp/winx-club-dress-me-up.html?callbackPage=StarDetailPageViewModel&callbackParam=hs_winx_club

See that little "Close game" button on the top right? That (after a prompt) closes the browser and returns you to the page you were on in the nick app. How does it do that?

Protocol activation of apps

Nickelodeon is using protocol activation, as you can see from the markup in this listing.

Specifically, this is the URI format that they're using:

<div id="metro-game-header"

     url="nickmetroapp://www.nick.com/callback?page=StarDetailPageViewModel&amp;param=hs_winx_club"><div class="header-container"><img width="569" height="128" id="header-logo" alt="Nickelodeon" src="http://images3.nick.com/nick-assets/games/nick-metro-app/nick-logo.png?height=128&amp;width=569&amp;quality=0.75"><img width="93" height="128" id="header-slime" src="http://images2.nick.com/nick-assets/games/nick-metro-app/slime-drop.png?height=128&amp;width=93&amp;quality=0.75"><img width="300" height="81" id="header-button" onclick="NICK.games.metro.appCallTriggered();" alt="Close Game" src="http://images2.nick.com/nick-assets/games/nick-metro-app/close-back-button.png?height=81&amp;width=300&amp;quality=0.75">

</div>

The parameter information comes from the URL that the app originally sent over.

If you have the nick app installed, click this link in your browser: nickmetroapp://www.nick.com/callback?page=StarDetailPageViewModel&param=hs_winx_club . It will pull up the nick app, just as you expect. Because of the parameter passed, it will even navigate to the specific page.

This works because apps can register protocols that they respond to. The primary reason this exists is to support things like browsers which respond to http and voip apps which need to respond to their own call-to protocols, but you can use it in your own apps.

Protocols are registered in the appxmanifest for the project. In this screen grab, I'm registering the pete-brown:// protocol. (For obvious reasons, there are a number of reserved protocols which you cannot register for your app. You can find them listed in this MSDN article.)

Once I deploy this app, if anyone enters "pete-brown://something_or_other" it will launch or activate my app. More on that in a moment.

What about multiple apps registering the protocol?

In Windows 8, the user is always in control. It's up to the user to decide which apps they will use to open specific file types or protocols. Via the prompts that come up when you open a file or URI (The "you have new apps which can open this type of file" prompt) and via the default programs in Control Panel, the user can decide which apps will be associated with the type.

Most users won't need to use this control panel section, but it's good to know it's there.

It's one thing to allow your app to be activated with just any random URI with your app's scheme/prefix, but what about passing parameters and whatnot?

Intelligently handling activation

Your app is in control of the URI format. You'll want to stick within the rules for URI formatting in general, but how you interpret what you see is up to you.

Inside App.xaml, override the OnActivated method and handle the case of protocol activation as shown here:

protected override void OnActivated(IActivatedEventArgs args)

{

    if (args.Kind == ActivationKind.Protocol)

    {

        var protocolArgs = args as ProtocolActivatedEventArgs;



        var fullUri = protocolArgs.Uri;

               

        // todo: parse the URI and navigate to the appropriate

        // page, or perform an action



    }

}

Once you have the Uri, you can break it into its component pieces.

NOTE

When you handle this type of activation, your app may already be running, or it may be a brand new activation and launch. Be sure to handle each case appropriately.

What could you use it for?

It's increasingly common for apps to provide deep links to their data. Contacts stores need to provide ways to link to specific contacts, for example.

This is especially important when it comes to implementing the Share contract. In that case, when you share something like a contact, you may want to simply provide a deep link to that contact's information in your app. This will allow you to share the link with anyone who already has that app. Same concept applies to customer information, or invoices, or other potentially useful app information.

One thing that makes Windows Store apps powerful is that they all play together to make the sum greater than the parts. The Share contract is a huge part of that, but so is protocol activation. Consider implementing it in your next Windows Store app.

Scaled DPI-aware image assets for Windows 8 Apps in Visual Studio 2012 Update 1

Pete Brown — Sat, 01 Dec 2012 18:32:19 GMT

With the latest update to Visual Studio 2012, the mechanism for specifying and verifying DPI-aware images has just gotten easier.

I've written and spoken about automatic DPI-aware image assets in Windows 8 apps in my book Windows 8 XAML in Action, and also at events. Here are the details, but in a nutshell, if you use a specific naming convention for images in your Windows Store app, for example logo.scale-100.png and logo.scale-180.png, your code can simply reference the root name (logo.png) and the runtime will handle pulling in the correct image for that DPI.

Specifying images

In base Visual Studio 2012, the file picker in the app manifest didn't quite understand this convention. To pull in DPI-aware images, you had to simply type the root file name in the textbox. Everything worked beyond that. In Update 1, the appxmanifest designer has been updated to better support these types of image assets:

Another nice change is that the "store logo" entry has been moved from the last tab to the first tab. This is a huge deal as the latest version of WACK now checks to make sure you have that logo in place. Those X logos you see in the Windows Store? That's from folks forgetting to update this logo. With it now on the first tab, it's much more "in your face".

Here's one of the examples from my book, created with the base Visual Studio 2012, and brought into Update 1 without me changing anything. It just works (the .scale-80 image was left out by me). the small numbers at the top right of the logo are to illustrate which image is chosen when run in the simulator.

Note that the appxmanifest itself only includes an entry for the base file name:

<?xml version="1.0" encoding="utf-8"?>

<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest">

  <Identity Name="7bb30b0f-fd80-4ea2-a0e6-c619d20c83fe" Publisher="CN=Pete" Version="1.0.0.0" />

  <Properties>

    <DisplayName>PhotoBrowser</DisplayName>

    <PublisherDisplayName>Pete</PublisherDisplayName>

    <Logo>Assets\StoreLogo.png</Logo>

    <Description>PhotoBrowser</Description>

  </Properties>

  <Prerequisites>

    <OSMinVersion>6.2.1</OSMinVersion>

    <OSMaxVersionTested>6.2.1</OSMaxVersionTested>

  </Prerequisites>

  <Resources>

    <Resource Language="x-generate" />

  </Resources>

  <Applications>

    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="PhotoBrowser.App">

      <VisualElements DisplayName="Photo Browser by Pete"

                      Logo="Assets\Logo.png"

                      SmallLogo="Assets\SmallLogo.png"

                      Description="Photo Browser sample app for my book Windows 8 XAML in Action"

                      ForegroundText="light"

                      BackgroundColor="#003060"

                      ToastCapable="true">

        <DefaultTile ShowName="logoOnly"

                     WideLogo="Assets\WideLogo.png"

                     ShortName="Photo Browser" />

        <SplashScreen Image="Assets\SplashScreen.png"

                      BackgroundColor="#003060" />

      </VisualElements>

    </Application>

  </Applications>

</Package>

In the project itself, I have images named with the system-recognized naming convention.

Testing your images

If you have multiple machines with different DPI screens, that's a great way to test, as you'll see exactly what the images look like. For most people, however, that's not the case. To test out the images, use the simulator. The simulator will do its best to show what the images will look like, but of course, without the available DPI on the host machine, the level of detail won't be the same.

It's a small change to Visual Studio 2012, but a welcome one. As a result of this, I expect to see more developers using dpi-aware images, and fewer developers leaving out the store logo.

Teaching a six (well, almost seven) year old to solder

Pete Brown — Fri, 30 Nov 2012 01:38:34 GMT

As a geek, there are a number of milestones or rites of passage for children:

First drawing of any vehicle with more than three guns
First original LEGO model
First time you figure out how to turn on the Xbox and get into a game without help
First time you solder something
First program written
First cosplay at a geek convention
First computer you build from parts
First date with someone who tolerates nerds or even out-nerds you

There are many, many more, especially depending upon the class of nerd/geek. Anyway, you get the picture. :)

My son sees me solder things all the time, and has always been interested. However, a soldering iron is something that, like your first pocketknife, requires a level of respect and self-preservation when using.

Tonight, I felt he was ready for it, so we worked on his first soldering project. The kit chosen is the Parallax S2 Robot Badge. This is a nice little "learn to solder" kit which gives you something interesting at the end: a model robot with a button that you press to make an RGB LED cycle through colors.

There are lots of other "learn to solder" kits, but most of them are more like practicing your writing by repeating scores of the same letter on a page until your hand cramps up; at the end, what you have to show for it is hardly inspiring and not even remotely interesting.

This kit has a grand total of nine solder joints, including some challenges:

LEDs are easy to burn out if you heat them up too long
The large metal battery holder is a giant heat sink, so it takes a totally different soldering style.
All the joints are small with relatively small solder pads (except on the opposite sides .. the large pads on on the wrong side, oddly)

But, what you get out of it at the end is this:

And more importantly, this:

Note that I did only one solder joint myself. Ben did the rest, including clipping the leads, all under my close supervision. The only thing he needed me to do was push the wheels on because they're a pretty tight fit (note that they don't rotate).

Before building this, I showed him how to solder using a resistor and a broken PCB I had. I did one side, he did the other. That was the only prep other than discussing the safe use of the iron (never take your eye off the tip, always place it in the holder when done, never get distracted, never drop it or put it down on the table, etc.)

All in all, a very worthwhile experiment that he showed surprising aptitude at.

If you're looking for a good kit to use to learn to solder, this kit, plus a fine tip iron and fine solder, is a really good choice and a very fine geek bonding moment.

Generating sound at runtime using XAudio2 in a Windows Store app

Pete Brown — Thu, 29 Nov 2012 07:11:43 GMT

In this post, I'll briefly explain how to generate sound in real time in a Windows Store C++ app using XAudio2.

I've always liked messing around with synthesizers. Quite some time ago, I built a simple synthesizer using Silverlight. It was cool, but very processor intensive. All the sound was generated in real time, and was then pushed into buffers which were read by the media pipeline. The pipeline was never meant for that type of sound generation so although it worked well, it had a fair bit of lag.

For a project I'm working on in my spare time, I need to be able to generate sound in real time for a Windows Store app. The user interface for this app also has to be really intuitive. It may have some interesting visualizations, but it'll be mostly standard UI type controls. I figured this was a good time to try out C++ with XAML in the Windows Store.

The project

So, I created a new Windows Store C++ plus XAML plus DirectX app. There are a couple different audio pipelines I could use. I decided to go with XAudio2 rather than WASAPI, as XAudio2 is much easier to get into, and has decent performance. Is XAudio2 fast enough for real-time sound generation? It has been shown to be so for many apps. In fact, the MorphWiz and Tachyon apps that Jordan Rudess played before Build 2012 used XAudio2 (although the developer may have converted to WASAPI by now in order to eek out some extra performance).

I added a single class named "Synthesizer". It's a bit much for me to call this a "synthesizer", but hey. :)

Keep in mind that I'm not a good C++ programmer; I'm still re-learning. The code here is shown just as a proof of concept, not best practices or anything like that.

The Synthesizer header file

#pragma once



//#include <wrl.h>

#include <pch.h>

#include <xaudio2.h>

#include <xaudio2fx.h>

//#include <mmreg.h>



#define VOICE_BUFFER_SAMPLE_COUNT (44100 * 2)



ref class Synthesizer sealed

{

private:

    int m_sampleBits;



    IXAudio2MasteringVoice* m_masterVoice;    // cannot use ComPtr for this

    IXAudio2* m_audioEngine;





    // this is temp stuff which will be rolled into another class

    IXAudio2SourceVoice* m_voice;

    XAUDIO2_BUFFER m_buffer;

    float m_bufferData[VOICE_BUFFER_SAMPLE_COUNT];



public:

    Synthesizer(uint32 sampleRate);



};

There's nothing overly exciting going on in that class right now. The thing that took me the longest to figure out was that I couldn't reference any of the IXAudio2* interfaces (other than the main one) using a ComPtr. The error was suitably cryptic for a noob like me.

The Synthesizer Class has a single XAudio2 voice (you can have multiple voices). And no: no destructor, I don't even clean up after myself. Remember what I said about this not showing best practices?

Synthesizer class file

#include <pch.h>

#include <math.h>

#include <Synthesizer.h>





Synthesizer::Synthesizer(uint32 sampleRate)

{

    m_sampleBits = 32;    // 32 for IEEE float



    // initialize XAudio 2

    DX::ThrowIfFailed(XAudio2Create(&m_audioEngine, 0, XAUDIO2_DEFAULT_PROCESSOR));

    DX::ThrowIfFailed(m_audioEngine->CreateMasteringVoice(&m_masterVoice, XAUDIO2_DEFAULT_CHANNELS, sampleRate));



    // 2 channels because this is stereo

    int channels = 2;



    // set up wave format using my good friend WAVEFORMATEX

    WAVEFORMATEX wfx;

    wfx.wBitsPerSample = m_sampleBits;

    wfx.nAvgBytesPerSec = sampleRate * channels * m_sampleBits / 8;

    wfx.nChannels = channels;

    wfx.nBlockAlign = channels * m_sampleBits / 8;

    wfx.wFormatTag = WAVE_FORMAT_IEEE_FLOAT; // or could use WAVE_FORMAT_PCM

    wfx.nSamplesPerSec = sampleRate;

    wfx.cbSize = 0;    // set to zero for PCM or IEEE float



    DX::ThrowIfFailed(m_audioEngine->CreateSourceVoice(&m_voice, (WAVEFORMATEX*)&wfx));



    //float noteFrequency = 22.5;    // A0

    float noteFrequency = 55;    // A1

    //float noteFrequency = 110;    // A2

    //float noteFrequency = 220;    // A3

    //float noteFrequency = 440;    // A4



    // there's probably a #define for this somewhere

    float pi = 3.14159265;



    // fill the buffer

    for (int i = 0; i < VOICE_BUFFER_SAMPLE_COUNT; i+=2)

    {

        m_bufferData[i] = sin(i * 2 * pi * noteFrequency/sampleRate);



        // stereo buffer. Slight detuning of the second tone

        m_bufferData[i+1] = sin(i * 2 * pi * (noteFrequency + 2)/sampleRate);

    }



    // the buffer will be looped infinitely

    m_buffer.AudioBytes = VOICE_BUFFER_SAMPLE_COUNT * m_sampleBits / 8;

    m_buffer.PlayBegin = 0;

    m_buffer.PlayLength = 0;    // play entire buffer

    m_buffer.LoopBegin = 0;

    m_buffer.LoopLength = 0;    // loop entire buffer

    m_buffer.LoopCount = XAUDIO2_LOOP_INFINITE;

    m_buffer.pAudioData = (BYTE *)&m_bufferData;

    m_buffer.pContext = NULL;



    // wire up the buffer

    DX::ThrowIfFailed(m_voice->SubmitSourceBuffer(&m_buffer));



    // start playing sound. Yeah, this is in the constructor. Yeah, I know.

    DX::ThrowIfFailed(m_voice->Start(0));

}

The code is commented in-line and should be reasonably easy to follow. Basically all I do is initialize XAudio2, fill a buffer with samples of a sine wave, then tell XAudio2 to play that buffer, looping it forever.

References

Then, I added a synth instance to the header file for the main XAML page, and then from the main XAML page's constructor, I simply created an instance:

DirectXPage.xaml.cpp header addition

#pragma once



#include "DirectXPage.g.h"

#include "SimpleTextRenderer.h"

#include "BasicTimer.h"

#include <Synthesizer.h>



namespace PeteBrown_DroneSynthApp

{

    /// <summary>

    /// A DirectX page that can be used on its own.  Note that it may not be used within a Frame.

    /// </summary>

    [Windows::Foundation::Metadata::WebHostHidden]

    public ref class DirectXPage sealed

    {

    public:

            ...



    private:

            ...



        Synthesizer^ m_synth;

    };

}

DirectXPage.xaml.cpp constructor addition

DirectXPage::DirectXPage() :

    m_renderNeeded(true),

    m_lastPointValid(false)

{

    InitializeComponent();



...



    m_synth = ref new Synthesizer(44100);   

}

Once again, yeah, I know I'm doing all this from the constructor. Don't shoot me :)

I then ran the app, and got the wonderful DX + XAML UI (two bits of text) with what sounds like a hearing test playing in the background. Clearly you can take this much further and do all sorts of neat things with audio generation in real time. For me, this was just a little proof-of-concept I had to work through before investing any real time in this side project. Concept proven, I'll move on to some other parts of the app.

For more information on XAudio2 on Windows, see MSDN. XAudio2 is a technology shared with the Windows Store (x86, 64, and ARM), the desktop, Xbox 360, and with Windows Phone 8, so once you learn it, you can apply it in all three places. For more information on XAudio2 on Windows Phone 8, see this MSDN page.

The update Windows SDK and Windows App Certification Kit tool (now checks branding images)

Pete Brown — Tue, 20 Nov 2012 20:50:31 GMT

A new version of the Windows Software Development Kit for Windows 8 was published last week. A new version of the Windows App Certification Kit (WACK) tool is included as part of this.

Installation

You can download the Windows 8 SDK from MSDN, here.

The installation is simple. I'll include the screenshots here so you can see what's included. Also, I encourage you to enable the Customer Experience Improvement Program as it really does help the product teams make better products.

The updated WACK tool

The WACK tool is an essential part of Windows Store app development. It's something which you should run not just at the end of development, but throughout the development process, or at least at milestones.

I'm going to check a Windows Store app created using the default templates, with no additional functionality added. The tile for the app (named App2) can be seen in this snip from my Start page.

You can see I forgot to update the app tile. I also failed to update the splash screen and store listing image.

The Barnyard Mahjong and cake stacking games are for my kids. Honest!

Now, we'll run the new version of WACK. The Windows App Cert kit shows up in your Start Page. It's quickest to find it if you just type "app cert" on the Start Page and then click the resulting item.

You'll then be prompted to pick a Windows Store app, Desktop app or Desktop Device app. The Desktop App one is for desktop apps that can be listed in the store by business accounts. The Device App is for OEMs and device manufacturers.

Pick Windows Store App and then select the app you are going to verify. Note that the app must be compiled/deployed to the local machine.

The tool took several minutes to run. While it is running, leave the PC alone, and don't interact with the app, even if it looks like it is stuck.

As you can see, my default app failed. This is new - in the previous version of WACK it would have passed.

WACK now fails your app if you use the default branding images

Let's see why it failed. Aha! I forgot to update all those logo images.

This is great because WACK is something you can run locally, and is also something that is used by the Windows Store team as their first pass verification of your app.

For other tips on how to get your quality app submitted successfully, see these posts:

5 tips to get your apps certified quickly (Windows Store for developers blog)
Building quality Windows 8 apps: Important pre-submission checks for your Windows Store apps (me)

Building quality Windows 8 apps: Important pre-submission checks for your Windows Store apps

Pete Brown — Mon, 12 Nov 2012 05:01:51 GMT

When you get ready to submit your app to the store, you'll run it through the WACK (Windows App Certification Kit) tool. That tool will report to you the most egregious errors, but it doesn't catch everything you'll want to do to finalize your app. In this post, I have a number of suggestions ranging from the most simple to some more interesting system integration ideas.

Have you checked the policies and certification requirements?

After running the WACK tool, you should manually check the Windows app certification requirements, as the Store submission process will do both, but WACK won't catch everything. For example, WACK won't catch apps that provide little value, or which are duplicates of other submissions. These certification requirements should be your minimum bar for producing a great app.

Did you set the right store colors and logo?

You set your splash screen and app tile colors. You have a normal and wide tile for the start screen. You've been seeing them all throughout the development cycle. However, did you set the store logo? It's easy to skip over this as it's in the packaging tab in the appxmanifest, the last tab, separate from the other logos.

By default, the icon is a white boxed X on a transparent background. That's not what you want to see in the store.

Update the StoreLogo.png file, or add a new one and set it on the last tab of the appxmanifest:

Be sure to update this logo. You don't want to have to resubmit your app just to fix the ugly X.

Looks great on your tablet, but how does it look on big displays?

The most popular devices for Windows 8 are initially likely to be touch tablets and hybrids which naturally have relatively small displays. If you want your app to see uptake in the world of developers and other people with big high resolution but low DPI desktop displays (I have two 30" displays, others have 24" or 27" displays), you'll want to make sure your app looks good at all resolutions. The world doesn't stop at 1366x768 or 1920x1080.

Not everyone has an 84" touch display available to them, but many businesses eventually will. A much more common display will be something like my 30" Dell at 2560x1600, or all-in-one PCs, like the Dell 27" which runs at 2560x1440, or even my Lenovo W520 laptop running at 1920x1080, but (by default) at 125% DPI.

This is really easy to test inside Visual Studio. You can use the device pane (see next topic), or simply run your app in the simulator.

When you run in the simulator, you'll get to try out the app at several different common resolutions and DPI settings.

You want to make sure your content flows well and makes good use of the available real-estate. As the owner of a large screen, apps which have a lot of side scrolling but which don't expand to fill the available vertical space make me sad.

Are you supporting snapped and filled state? Rotation?

All apps in the Windows Store need to support a Snapped view (the 320px view you get when you snap an app to the left or right), a Filled View (the minimum 1024x768 view that remains when another app is snapped), and the full view. This falls under store policy 3.6 "Your app must use the mechanisms provided by the system for those features that have them". Apps should also support rotation. Here's the set of states using an illustration I created for Windows 8 XAML in Action.

This is also very easy to test inside Visual Studio, as long as you follow the patterns used in the default templates. Specifically, if you use the named Visual States for the different views, you can use the device pane in Visual Studio to try them out at design time. The device pane lets you switch between full, filled, snapped, and portrait. Behind the scenes, it sets the appropriate visual state and updates the view in the designer.

Note that the device pane also lets you change the display resolution and DPI to make sure you look good on different types of displays.

Do you support all three primary input types? Touch, Mouse/Touchpad, Keyboard?

Store policy 3.5 states "Your app must fully support touch input, and fully support keyboard and mouse input". This means you cannot have hover or right-click as the only mechanisms by which you can get to certain functionality. Similarly, requiring a pinch gesture without providing an equivalent for mouse and keyboard would also be a violation of this policy.

It's tempting to also make related assumptions. For example: assuming that if the user has touch, they also have an accelerometer. Sure, that's true for almost all tablets, but not for touch desktops like the Dell XPS and Lenovo A720. Similarly, assuming that keyboard is available if accelerometer is not completely ignores kiosk-like scenarios.

Do you have data? Have you made it searchable? Do you share it?

Most apps have data in the form of traditional data, contact information, timelines, images, files, or more. Don't let your app be an island, instead, let it provide value to other apps in the system by making the data sharable. In fact, if your app because an essential source of data (or a good place to send data), people will use it again and again.

The Share Source and Share Target contracts are both easy to implement and provide a lot of value.

While you're there, make that data searchable. Again, if the user can search inside your app, they're more likely to use it. Don't provide a separate and unrelated search feature inside your app. Instead, integrate with the search charm.

How is your performance on ARM?

ARM processors are optimized for a balance of performance, portability, and low power. When compared to the typical developer workstation, ARM devices are going to have significantly less power and memory. Additionally, although the operating system abstracts away almost all of this, how the processor works internally is different from how an Intel x86 compatible processor works. For those reasons, you'll definitely want to test your apps on ARM-based devices. You may find that you need to flatten your visual trees a bit, or load fewer items in that ListView, or perhaps make more aggressive use of virtualization in panels. When working with DirectX, you'll need to make sure you're using the correct level of DX supported on ARM devices.

Start testing on ARM-based devices early on and you'll avoid headaches down the road.

Turn off unused capabilities

Declaring a capability but not using it can cause your app to be rejected from the Windows Store. By default, all apps have Internet capability checked. If you don't use the Internet in the app, uncheck this. Same thing if you did some testing with, for example, the webcam and later decided not to use it.

Final word: take testing seriously

Submitting your app can sometimes be a lengthy process, especially in busy times such as around the launch of Windows 8. You want to minimize the number of times your app is rejected. Ideally, you want to submit once and then just start making money (or gaining fame).

Just because Windows Store apps are typically simpler and smaller than desktop apps doesn't mean you should pay less attention to the details when putting them in front of the public. In fact, due to the increased visibility offered by the store and the user-centered ratings system, and the external review mechanisms, you'll want to pay more attention than ever.

Finally, don't forget that privacy policy.

How-to: Name Start Page groups in Windows 8

Pete Brown — Mon, 12 Nov 2012 03:26:46 GMT

By default, your Windows 8 Start Page appears as a base group of standard apps, plus a group of desktop apps (if you upgraded) or Office apps (if Surface with Windows RT). Most of us create a number of additional groups beyond those. Those groups are not named for you automatically. Did you know you could name those groups to make organization easier?

Here's how.

On the Start Page, use Semantic Zoom to zoom out and get a higher-level view of your groups. If a touch screen or multi-touch pad, use a pinch gesture to invoke semantic zoom. If using a mouse or older style touch pad, move to the bottom right corner and click the "-" you see next to the scroll bar.

What you'll then see is the zoomed-out view of your start page. Note that semantic zoom works in many apps, like the People app and photos apps.

Right-click to select a group (or pull-down if touch screen). You'll see a checkmark appear on the selected group The app bar should automatically appear, but you can also pull it up by swiping up from the bottom or right-clicking on the page.

Click or tap the "name group" button on the bottom left. In this case, I'm going to name the group "Kids" because it's a set of games and apps for when my kids sit with me in my office.

Repeat for each group you want to name (you don't need to name all of them). Now you have named groups.

Sometimes coding a solution is faster than finding one: Simple Webcam app in Silverlight 5

Pete Brown — Sun, 11 Nov 2012 20:08:26 GMT

I recently upgraded my main desktop PC to Windows 8. When I did that, the Microsoft LifeCam software stopped working. It was recognized as incompatible with Windows 8. For most people, this is not an issue, as it works perfectly fine with the built-in Windows 8 camera app.

For me, however, I need a small camera app sitting on my desktop so I can see the hallway leading to my office. I call it the heart-attack preventer, as it makes it difficult for my children to sneak up on me when I'm heads-down at work. This is because I'm surrounded by displays and simply can't see over them. My home office is in the basement, with a combined TV room and play room (plus a bunch of storage) surrounding it, so the kids often sneak in here to say "Hi".

I installed the latest version of the LifeCam software, and it doesn't install the desktop camera app at all. Bummer. I quickly checked, and this is a common observation about that install.

Rather than spend all afternoon looking for a solution, I figured it would be easier to code my own in 15 minutes. I considered using WPF 4.5, but WebCam access in WPF requires third-party toolkits or DirectX code (or Win32 API calls), so that wouldn't do it. Coding a solution as a Windows Store app wouldn't do, as I need a very tiny window on my desktop, not a snapped app. I sometimes snap other apps and wouldn't want the webcam app to limit that, or take up that amount of room.

Silverlight has always had extremely simple WebCam APIs that are quick to use. (WinRT's APIs are just as easy if not easier).

I created a quick Silverlight 5 project in Visual Studio 2012. Made it an out-of-browser app with elevated permissions, and put this as the MainPage.xaml markup

<UserControl x:Class="SimpleWebcamSL.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="300" d:DesignWidth="400">



    <Grid x:Name="LayoutRoot" Background="White">

        <Rectangle x:Name="VideoOutput"

                   HorizontalAlignment="Stretch"

                   VerticalAlignment="Stretch" MouseLeftButtonDown="VideoOutput_MouseLeftButtonDown_1" />

    </Grid>

</UserControl>

And this as the code-behind:

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;



namespace SimpleWebcamSL

{

    public partial class MainPage : UserControl

    {

        public MainPage()

        {

            InitializeComponent();



            Loaded += MainPage_Loaded;

        }



        ReadOnlyCollection<VideoCaptureDevice> _devices;



        void MainPage_Loaded(object sender, RoutedEventArgs e)

        {

            _devices = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices();



            // specific to my system. Camera 1 is the one that points

            // out of my home office. Camera 0 points at me.

            if (_devices.Count > 1)

                SetCaptureDevice(_devices[1]);

            else if (_devices.Count > 0)

                SetCaptureDevice(_devices[0]);

        }





        private void SetCaptureDevice(VideoCaptureDevice device)

        {

            var source = new CaptureSource();

            source.VideoCaptureDevice = device;



            var brush = new VideoBrush();

            brush.Stretch = Stretch.UniformToFill;

            brush.SetSource(source);

            VideoOutput.Fill = brush;



            source.Start();

        }



        private void VideoOutput_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)

        {

            Application.Current.MainWindow.DragMove();

        }



    }

}

I set the project properties for out of browser, no window border, and elevated permissions (all covered in my Silverlight 5 book) and then installed the app. All done in about 15 minutes. It took longer to write this post than it did to create the app.

This is hard-coded to my specific situation (second camera is the camera which points away from my desk). I didn't bother with icons, camera switching, or anything beyond what I needed for this specific situation.

As a woodworker, I find it's sometimes quicker for me to build something as opposed to search stores to find what I'm looking for. As a programmer, sometimes it's faster just to code your own solution rather than search the internet all day for workarounds. :)