>> Rick Barraza: So this is a talk about dangerous ideas. We’re going to be covering five dangerous ideas tonight. I know I’ve been invited here under the auspices of speaking about apps and having nice designed apps. We’re going to get to that point but we can’t really talk about design unless we zoom out and talk about creativity. Creativity itself is a dangerous idea, because creativity forces us to ask why, not just how. When you mix creativity with technology you get a very volatile combination and that also is dangerous. But these five ideas aren’t going to be dangerous tonight just because of that.
The five ideas I’ll be arguing for tonight maybe dangerous because they might go against what you believe about code, what you believe about programming. What you’ve been taught to believe makes a good app, makes good design. How people should think about it. It might force you to think as we move from a software engineering company to a devices and service company, just exactly what type of developer is going to be best suited to take advantage of that transition in our own Microsoft future.
These might be challenging to you. I hope they are.
I personally believe them, what I’m going to be saying the next five ideas that we’ll be talking through.
Doesn’t mean you necessarily have to believe them. In fact I kind of hope you don’t. But it’s important to me that we have this debate because these five ideas I don’t think we’re talking about them enough here at Microsoft. It’s what I’m passionate about. It’s what my career has been focused on. It’s these conversations I think we desperately need to get, to continue to be relevant and to thrive in the future that we’re building out for ourselves and for the world.
So the only thing I ask of you is an open mind for the next hour. Let’s go through these ideas. So let’s get started. Here’s the first idea. You can’t have great design without creativity. This might make sense on the surface, when you think about it though a lot of people don’t act as if this is true. They’ll find a design, they’ll try and pick it from somewhere else, and then they’ll bring it on to their platform. But it hasn’t actually been natively grown.
The challenge of this is based into the word design itself because design is both a noun and a verb. So there is a duality to design. We’ll talk about it. People will often talk about design as a noun; I like the design of that app. But if you talk to designers, you talk to professionals they usually think of design as a verb, I design great apps. When we think of design as a verb it’s this behavior that we go through. So as you’re building your apps if you’re really going to be designing your apps this is what great design looks like when you ask professionals what design is.
This is from Donald Norman; great design is visceral design, plus behavioral design, plus reflective design. Visceral design is that gut feeling of that ten second wow when you fire up an app. When you do any experiences and just for apps this is design in general. What’s that feeling that you immediately get? That’s the visceral design. Behavioral design of course is how it works. Is it stable? Is it solid?
Reflective design is, is this app, is this operating system, is this device reflecting back onto me the tasks, the apps, the desires that I want to embrace in my lifestyle? Is it reflecting back on me what I want to do and the types of experiences I want to have? All three of these together is what makes a great app.

But in order for this process of design to really be sustainable it requires creativity. Because those artifacts, those nouns that most of the world thinks about when they say design, that fruitage that grows off the tree which is the process of design. That tree requires a fertile territory of creativity and creativity looks very, very different from how a lot of us might be use to writing code and writing apps, because creativity requires four elements to thrive. It requires exploration, experimentation, the freedom to fail, and most importantly fun.
These four things in any OS, in any app, in any device, in anything you build if you can nail these four things you will start generating and churning through creativity. You’ll be attracting creative talent and you’ll be generating creative talent. As you mill the soil of creativity good design eventually starts growing. I say eventually because most of us are comfortable with exploration and experimentation.
But a lot of us aren’t too comfortable with this. A lot of us don’t even think of this as being on our score cards. But these two are actually two of the most important ones in order to get a sustainable level of creativity. You need a sustainable level of creativity to get that design and to start consistently generating a harvest of well designed apps and well designed experiences.
The second idea and these kind of build off of each other. So once we kind of have an understanding of what design is in the context of creativity and more importantly why creativity is important. The next dangerous idea that builds on that is this, the main space of delight. Here’s what I mean. At Microsoft our Windows Store when we’re thinking about apps there are many times we have a very binary concept of apps. You might have heard this yourself. I know I’ve heard this in the almost two years I’ve been here. Well is it a game or is it an app? It kind of makes you want to choose one or the other.
Whose it for, is it enterprise or is consumer? Enterprise to consumer creates a spectrum of potentiality.
Same with transactional to immersive, I’m not going to use gaming because actually we’re talking about immersive experiences. That paper app that a lot of the ex-courier guys made that’s on IPad. Is that a game or is that a transaction app? You know where exactly does that fall in? Its value is that it’s immersive. The crafting of the light there isn’t the same thing as building a game. You’re creating a delightful experience for whatever your app is trying to do well.
So instead of thinking of these as binary if you work at an agency, you know I was creative director at company of record for us before joining Microsoft. Anybody who walked in through that door regardless of what type of app or experience they needed would fall somewhere on this domain space of delight. No matter where you fall you can craft a delightful experience but it would fall somewhere between transactional to immersive, somewhere between enterprise to consumer.
A challenge we have at Microsoft and one I’ve been finding, is we make gazillions of dollars down here at the transactional enterprise corner. We’re really, really good at that. We also make gazillions of dollars up at the highly immersive consumer targeted corners. So we kind of do want to fill into this well what bucket is it going for? But what’s interesting when we talk about crafting delight, and creative coding, and the changes that have been going on in the past decade. Is that most of those experiences have come in from this kind of mid band over here. That sometimes we get a little uncomfortable with.

But if you understand this graph there’s one more dimension I need to add to it. That’s the dimension of data density. These three dimensions plot the domain space of delight. As a professional designer if you’re working on your app your app is going to fall somewhere in this cube. Where it falls on that cube will determine what type of design it has, which will determine what type of delightful experience you can craft for it.
Let me give you some examples here. Visual Studio, it’s enterprise focused, it’s highly transactional but it has a very high data density. Whereas CRUD app will create, read, update the lead app you want to add a time card. It’s a very low data density but it’s just as enterprise and just as transactional.
Something like a basic weather app still transactional but it’s focused for consumer and it usually has low data density. Now gaming is interesting because you can have something like HALO which we normally thing of as gaming, which is high data density, a lot of vertex shade or a lot of shaders going on, a lot of 3D modeling going on, a lot of rendering going on, high data density, highly immersive, highly consumer. But then you could have something like Angry Birds. You’re just as immersive, just as consumer focused but its low data density.
What is delightful about each one of these apps and wherever your app is going to be falling on this domain will help influence how exactly to kind of churn out, coal out the light from your experiences.
One challenge we have is for Windows Store a current design guidelines which I believe in are very optimized toward low data density. They’re optimized toward transactional. They’re doing a very good job of balancing out enterprise to consumer. Again they’re doing a great job and our messaging is very strong on this. But against the cube of possible experiences there’s still a lot of area that undefined.
We should ask ourselves, why is this the case? Is there something specific to how we think about code that is causing us to be over optimized in these areas? I think there is. It takes us to the third dangerous idea. This is going to be one of Legos versus Clay. The argument is that there are two ways of looking at code. There’s a way we look at code traditionally here at Microsoft. Not just Microsoft the world of classical engineering. But there is an equal opposite equivalent way of looking at code. This metaphor of Legos versus Clay might help us to kind of understand what I’m talking about. Legos are great for certain reasons. They’re highly object oriented. They’re very valuable on reusable, the reusableness of this, right. It’s repeatable the way you work with Legos. Most importantly it’s dependable. You can build and it scales. These are great engineering qualities to have.
Clay on the other hand is free form, very expressive, exploratory in nature, and disposable, which shouldn’t be taken lightly. There’s value in being able to whip up a quick sketch in clay, mess it right up, throw it away, splatter it, build something, and that’s not even your final, it’s not even a beta. It’s not even your finished thing. You’re going to have to rebuild it again later on but you’re using clay because you’re exploring ideas. You’re trying to figure out and pull out that delight from whatever you’re trying to build.

I don’t want to take anything away from Legos. You can be very creative with Legos. In fact there are very few things cooler in this universe than a star KR-KN, right than a Space KR-KN destroying a star destroyer. That’s just one of the coolest things I’ve ever seen. You can be creative with Legos of course.
What’s interesting is Legos though the process you generally start, Legos are themselves components.
You start with a template, most people do, right. Most of us don’t instantly become Lego masters creating free form whatever we want. Most of us start with a template. Think of it in terms of components and then build something that’s already been conceived somewhere else, even when we think about this. Again, I love Legos, very, very cool. They can be very expressive.
But seriously here if we’re talking about professional, not even professional but just passionate design.
If your desire is bringing shape and form to an idea that hasn’t been expressed before, if it’s really about innovation and breaking the barriers clays what they teach you. You don’t go to art school and have a class on; you know have a course on Legos. You might, right that would be an easy A, right. That would be like a fun class.
But come on Stan Winston when you’re working on Hollywood. It’s not just Hollywood, kids with Playdoh. Lego innately has these properties for also being creative. They’re both equal, they both have that sense of creativity but the way you work with Legos is very, very specific, and very different from the way you work with clay. The level of detail is great. Now for most of us I’m going to assume maybe a lot of you, if you’ve come to this talk on creative coding, most of us here in twenty thirteen we got our start in Flash. Can I just see how many people actually maybe started with Flash, or played with Flash back in the day, alright, cool.
Flash was that revolutionary technology. That was that first digital lump of clay that a lot of us had been waiting all our lives for. It said here be smart and creative at the same time. It’s okay to be messy. This was revolutionary for us. I don’t want to oversell it but Flash in a certain way almost single handedly helped us do this transition from Web 1.0 to Web 2.0. Web 1.0 where it just works to Web 2.0 it’s delightful. It was Flash that did this. These were the experiences that Flash started enabling in the early turn of the, of this twenty first century.
It re-changed what we thought was possible for creative coding, for coding in general, for interactive experiences of delight. It’s Flash that did this, for a lot of us Flash was this first love for us. It let us be messy and we didn’t know what we were doing. Right, you have street artists coming in tattooed all up and they’re writing books that are best sellers. You know Flash to the Core by Joshua Davis who goes on and works on the UI for Big Blue from the Jeopardy computer, right, yeah.
So Flash did this for us. Flash was amazing. Flash gave this to us and it changed. What’s interesting is once you move from something being functional to something being delightful you can’t go back. This is, we’re going to get back to this point in a little bit. But something happens during this fundamental clay technology that Flash was. It gave us this acknowledgement that it was okay to be messy. It didn’t have to be about components it could be about clay, it could be about mistakes.

The Lego builders come in and they say here let me fix that for you. Say hey, let me look at what you’re doing, oh my goodness you have a go to and play frame thirty on your timeline. Where in the world is the code for that? It’s buried behind a movie clip on this, what’s going on here? You have no object oriented, you have no MVC, you have designers writing code. Designers don’t write code. Why would they ever want to write code? Designers like mark up. The big meem at the time was designers don’t code. They need mark up on the front and we’ll put the code behind in the back for the real programmers to come in and do their thing, right. That’s nice, thanks for playing clay but this is a Lego world.
They get Flash and they turn it into a Lego scalable product. That’s not wrong because even for anything that’s dependable clay can be very expressive. You get to a certain point if you don’t think architecture just falls in on each other, right. I’m not arguing for clay over Legos. I’m making the point that these are two equally valid ways of looking at code. The reaction of course to that for most of us here originally
Flash don’t Edison my Tesla, Bro, right. I mean I like coding messy. I like playing with clay. Don’t instantly try to over engineer and over optimize it. But Flex is needed because at a certain point the creativity and innovation generally comes from clay. Then Legos comes in when you need to start investing on scale, on reusability, on dependability. This is the way business works until it’s very valid and Flex became important for businesses making a lot of money. But Flash kind of stayed that fertile area of creativity for it allowed artists to be messy, to sketch.
Microsoft like many others at the time because we have Legos in our DNA. It’s how we think about programming and we’re optimized for that. We like that concept of some XML based definition on the front end and real code on the backend. So we bring in WPF. That brought in WPF3D which let us do some really cool things and make it accessible. XNA which didn’t have the market on the front and was pretty much one of the closest to the clay type of technologies we had. Of course Silverlight started as
WPF/E everywhere. These were good tools. These were good Lego tools.
A lot of us coming from the Flash world made a lot of good money brining our clay techniques into this space for Microsoft. But while Microsoft and many other of the, those that are in the business of software and we are we’re following the Lego model, which you need for scalability. Something interesting happened in the clay world. Eventually they needed more so Casey Reyes, Ben Fry, John
Maeda at MIT they started off with the draw by numbers.
This trend started coming in that coding stopped being just for people wanting to be serious computer science degree holding programmers. Everybody was slowly starting to realize that code is the medium of the day. Artist started realizing that code is the relevant medium of the day. Fashion designers started realizing that code, architects started realizing that code, many, many industries started needing to code. They don’t necessarily think in this Lego model world that works so well for us.
MIT starts off Processing and it really explodes up. Today it could be argued it’s the lingua franca of programming. If you’re not in the business of software processing is usually the first language you learn.
If you go to Kahn Academy and you’re a young person and you want to learn programming they teach

you processing. We come from a world where our first application most likely was a hello world. Then two hundred pages later into our C++ book we might actually draw something onto a screen.
The world today in twenty thirteen, most people unless you’re becoming that type of program their first app is drawing a red circle on the screen. That’s their first introduction to programming. This entire concept of shifting from compiler up to experience down is already out there and Processing now is the lingua franca. Processing was Java based and eventually they needed even more. Because designers and creative’s needed even more power so Parsons School of Design, Zach Lieberman, a couple others they wanted to get all the way down to C++. So they create Open Frameworks. It’s an abstraction library for working with C++. It comes out of Parsons School of Design.
Couple years later as Canvas starts getting important, HTML5 starts getting here, John Resig starts porting a lot of the processing concepts to be viable in the browser, we have Processing JS. Twenty ten the Barbarian Group who just finished winning the gold lion at Cannes a couple months ago for their work on Cinder, open sourced their abstraction libraries. I think here I’ve heard through the grapevine
MSR has their own abstraction libraries, right.
They work because you want to get the most pool out of your code doing C++ to the GPU is the best way to do that. Especially as we move from a plugged into the wall unlimited CPU and GPU world to a devices world where it’s calculations per watt and cost per pixel, of course it’s going to be C++ in the
GPU. These are abstraction libraries that the open source community; that they clay developers started working on iteratively to be able to experiment lower and lower into the computer. But again they’re not thinking compiler up. They’re thinking C++ experience down. That requires abstraction libraries.
These are the types of experiences that I’m talking about and the types of developers I’m talking about.
When we release the connect hardware, Cinder, the Barbarian Group, right. Robert Hodgin’s creates this Body Dysmorphia video. Like a week after, week after the drivers get out, Robert Hodgin’s starts doing this and it starts going viral. We and especially MSR and I want to give MSR the props that they deserve, have always been, are having a good relationship with these people. But in the rest of the company we’re not really having that many conversations with them. These are the people that were creating the connect experiences a year before we released our own Windows Drivers. They had to use
Hacked Open and I Drivers on our own hardware using C++ in Visual Studio. But because they don’t look and act like our traditional MVPs they’re pretty much this dark matter of our developer universe.
The last thing I want to bring out the Paper Route. As we know a lot of the people here from Paper that came out and just exploded as one of the best experiences on the IPad. They were the people who were working on Courier. So I write them up. I go hey do you use Open Framework Cinder? Because
I’m giving this talk, I’m trying to figure out you know what’s out there. He writes back and he says a number of us both on the engineering and design side at Fifty-Three are former Microsofters. I use to work on Bing Maps, Street Side, and Photo Synth. Currently Papers rendering components are all written in Cross Platform C++ using open GLES for both ink rendering and other views that showed journals and pages. Our production code doesn’t use Open Frameworks or Cinder it’s all custom. We

do develop prototypes using Frameworks as well as lighter weight technologies like JavaScript. This value of when you’re creating experience that’s never existed before and you need to experiment, and you need to fail, and you need to be driven by fun and passion. Your prototyping rapidly, you need to think of code in a way that fosters that. That’s not components and starting with templates and putting code behind. It’s these types of transitions, which leads to the forth dangerous idea.
We are currently in a war of attrition for hackers of delight. This is not about platforms. This isn’t
Windows versus Apple at all. This is paradigms, how you think about code. Because again all of these run on Windows 7, and most of them with the exception of Processing which has its own IDE, all of them have strong Visual Studio support. They all are creating experiences that they try to reach as broadly as possible. So of course they’re using OpenGL because that also ran on our desktop. It’s a way how you think about code. We’re doing this and again some of us are bilingual we would take the tricks from over there and make good money bringing them down into here, so we’re fine as well. But this was the echo system we had.
So before I show you the next slide I want to make sure you know that I work at Microsoft because I believe in Microsoft. I believe we’re in a good position and we’re going to go that way. I believe in WIN
RT and I believe in our strategy. I came here because of that. Because Build 2011 convinced me to leave my job and Microsoft was going to be able to help build the future. But this is what happened last year.
I knew this coming in. Windows Store Apps, WIN RT because it’s DirectX only for right now Cinder
Processing, well Cinder, Open Frameworks, Processing, all of the abstraction libraries that use Open JL they can’t deploy on a Surface RT, because WIN RT is DirectX only.
We also went ahead and don’t have these on our Windows Store applications. Well you say well Rick well we still have double, we still have C# and XAML. Yeah that’s true but it’s not the same thing as WPF because every language and every paradigm has kind of a, probably should’ve done it as a slide instead of my hand shadow. But you have the zone of probability and then you have a much broader zone of possibility, right. Here are the things you’re most likely going to do with this language. Here’s actually the broader zone of everything you pretty much can do with that language.
WPF was great because it had a very clear way of thinking about software and data binding, and MVVM, write and components, and storyboards. But it gave you all this messiness to. It was great. It gave you
WPF3D. It gave you pixel shaders, not necessarily vertex shaders because, so that’s great. We though and I agree with this decision optimize C# and XAML for Windows Store. We definitely reduce down that zone. We’ve made C# and XAML lean and mean, and really tight for certain types of template derived applications. But you can no longer do 3D, which for us was our hack, right. We came from the clay world bringing all our Felix the Cat bag of tricks, right.
We can’t do shaders anymore. We can’t have non-rectangular clipping path. We can clip as long as it’s a rectangle. Masking all that’s going because it’s become lean and mean for a certain type of app and it’s very, very good at it.

If you want to do anything other than that you say, ah, well you have to do it in C++ and DirectX. But again war of attrition C++ DirectX 11 first how many schools are teaching DirectX? Again, preface it I love DirectX, it’s an amazing technology and just metrics to metrics I believe it is stronger and better than OpenGL. That’s not the point I’m making. When I walk into a bookstore and there’s tons of
OpenGL ES2, there’s tons of WebGL books, there’s three books right now on DirectX 11. All three of the books are obsoleted on Windows 8. Because all three of the books use a D3DX library that’s also not supported on Windows Store.
We have HTML and Canvas but at this point last year we didn’t have WebGL. This is the depressing slide, ha, ha, of the talk. It gets better, you know so don’t leave now or you’ll just leave depressed. It gets much, much better. But this is being frank of where we are. There’s one of the values in DP in having this conversation so he can understand it’s not that they’re not here because they don’t want to be. It’s just we kind of undercut the abstraction libraries that they’re used to. Now we quickly need to start filling it back up. Not only do we undercut it to them. We undercut it to the agencies where I come from that were getting paid for making amazing things here. It’s really, really hard to do something that’s not transaction, that’s immersive on our platform.
Let me put it in much more easy way. Is it fun? Is it fun for you to code, to experiment on a Windows
Store app? If it’s not fun, if it’s not delightful you’re not going to get fun and delightful. So here’s some of the things we’ve been doing. Now it starts getting better. Unity, we lost XNA but we got Unity. This is amazing and this is Hina over in DP as well as a lot of other people, George Arsardo. They’ve been pushing this through. Unity this is a good choice because Unity lets us deploy, and let’s gamers deploy, and indie’s deploy across all the platforms they want.
We’re getting in there as a first party level of distribution for Windows Store, going out to Phone. This is really good. I heard thirty percent of all Unity apps aren’t games focused, right. But forty-two percent of all statistics are made up on the spot, right. But I heard thirty percent those of the types we’re talking about. There’s a reason when I’d go to even MSR’s Tech Fest. How many times in MSR did you have to use XNA because it was the easiest way of throwing in a 3D model and then doing some crazy MSR vision on them? Everybody used XNA or Silverlight as you need to start creating Windows 8 what library are you going to use? Unity is there for you.
Processing JS because we have JavaScript, again brilliant idea, I thoroughly laud it. Processing JS can come over and I’ve create around 6 hours of content on Channel 9, courses on teaching you how to use this. But it’s still only 2D. But the biggest one is MSOpen Tech. After banging and knocking on their door and really just begging they took on the challenge of porting Cinder over and they did it. UBeing
Cinder for Windows Store and it’s there. It’s the first iteration but this is good. I’ll be showing this code specifically because I was really, really excited that we got this. But Cinder now can port to Windows
Store. There are a couple things we’d like to do but we get that there’s Cinder’s there now.
This is the serious one; it’s a C++ abstraction library, fire Visual Studio 2013, making a Windows Store, nothing fancy but you bring it in and you now have an abstraction layer that lets you easily have fun, and

explore, and create NC++. The rest of the world was doing it. We like to think you know C++ is the much more reserved, you know gray beard technology. The rest of the worlds using C++ for fun, artists are coding C++ because these abstraction libraries are giving them that power.
I do want to call out a couple other efforts that I think are worth mentioning, Roberto Sonnino from, and more people from the Visual Studio Team created a Visual Studio 3D starter kit. If you did want to start looking at DirectX 11 natively you definitely start there. Shawn Hargreaves and Chuck Walbourn of XNA fame were able to map a lot of the thinking that’s something that’s called a DirectX Toolkit. If you’re coming from XNA you want to be experimenting with this I would definitely start there. A lot of us though didn’t come from XNA but if you are coming from that those are great, great tools to check out.
Data driven documents I’m not sure exactly what the support is yet. It’s one of the things next on my list. But my buddy and also Flash Guru from back in the day, Grant Skinner created Create JS and Easel
JS which are amazing for JavaScript based applications. So if you’re going to JavaScript you have support starting up now. If you’re coming from the Create a Space you can at least start at Cinder and some works with Processing. If you’re coming from this stack down here you can be jumping into here. So we’re getting these tools, just a lot of people aren’t talking about them. I’d love to see us start using these more as we’re figuring out our delightful experiences.
The biggest news and the thing that made me really, really happy this year after we got Cinder, 8.1
WebGL, this is huge for us to get back that credibility on this stack up here. It’s really, really, really big.
WebGL is coming to a Three JS support. Another home grown feature of one of our DP big brains out of
France created a library just recently released called Babylon JS which might help out. If you still don’t trust this kind of open source way of doing things, I know these are dangerous ideas. Also most importantly Cocos 2D which is a good gaming platform, but there’s a difference here between what I’m talking about and these types of things like Unity and Cocos 2D.
I fire up Unity, I fire up Cocos 2D they’re already assuming I’m in a game space. You start a DirectX sample or at least at 8.0 they’ve changed this now and we’ve been talking with them to try them to change that. It would be well, what’s your game renderer. But we’re talking about experiences that aren’t necessarily under the paradigm of gaming. Its experiences that are messy by nature. So this is really good. Our future is getting there and it’s very, very bright.
We can be working on this, if you wanted to learn more about any of the things up on the board please let me know. Afterward I can definitely be helping you out with the samples and tutorials that I’ve been finding. This is really the feel good slide, we’re working on it. It’s a work on progress to build those bridges back to the clay area.
I’d say that our last dangerous idea though is that it’s not about experiences, or excuse me it’s about experiences. Let me read my own slide here, what did I, it’s about experiences not apps. I really do believe that we can win this and it’s dangerous because of this. If you haven’t seen Bill Buxton’s talk a couple week back on Build on Ubiquitous Computing, please go see that now. I apologize ahead of time

for Mr. Buxton because I will most likely misquote him and probably misrepresent him. But as of right now I’m co-opting his ideas because I thought it was just brilliant. Brilliant talk but here’s my main take away from this.
We talked about that shift that happened in Flash with the web, Web 1.0 to Web 2.0. First it worked, then it had to be delightful, and once you got to delight you really can’t go back. This is how Bill framed this, the idea and really expanded on it. That there’s these miracles that define delightfulness. When computers first came out in the late seventies and all of sudden you can get the kit and make it yourself, right. You had to save after sixty bytes because it was going to buffer out at eighty bytes, right. It was just really, really painful back in the day. But we loved it, the little Timex Sinclair’s, right, and those old machines and we loved hacking on them. It was painful and we’d hook it up through an RF receiver on the TV and everything would be fuzzy, right and making those phone calls. It was great; it was delightful because the miracle was that it just worked, ha, ha. The fact that all of a sudden we had a computer in our house was insane. It exists, it works, that was the miracle that was delight.
But as we lived and survived through Web 2.0 and now we’re entering into this PC plus world of devices of ubiquitous computing, with all these other things. Today people expect it to work. What they really want is for it to delight them. That’s what the drivers doing now. You can’t just give them delightful.
You just can’t give them a magnesium shell and think it’s going to be a premium product. It also has to be a rock solid OS. But if you have these two things because they’re assuming that it works, but you craft delight, you get adoption, and its delight and dependability that bring adoption. It’s not the number of apps you have on your store. Delight and dependability right now today is what gets adoption.
This is what we’re trying to improve more. This is what we’re wrestling on, or this is what we’re working through, and this is why I’m here to help us with that. But Bill makes a really interesting point. The future though, once everybody is expecting the experiences to be delightful and so of course expecting them to work, the next wave of delight will be is it interconnected? Is it connected? Because that’s the delightful experience I’m expecting now. I’m expecting to be on my Windows phone and get in the car and it seamlessly carry the phone call over so my phone becomes the car. I get home and it seamlessly comes up and I walk into my house and it seamlessly transitions. That all of my apps and all of my data, and all of my experiences are shared and collaborative, and they communicate, that will be the delightful experience that will be driving the next ten years.
So if we can go through the hurdle of delight really investing in creativity, not just trying to pour it over design, or not just thinking of design as the nouns, but we really get to the verb of design. We get to that area of creativity we’re all set for the future and here’s why. Our competitors, most of the world this is how they think about what they’re doing. You might have come in here with an app in mind that you wanted to build. You might be thinking about it like this. I’m building an app but we’re already in
2013 Microsoft Windows 8.0 moving into 8.1, already past this. Routing out your minds, we’re in an area right now that it’s not just your app as a finite noun, it’s your app as a verb, as an experience. It’s your app that gets to leverage shared identity that we’re doing. It’s your app that gets to leverage and

assume a cloud across their devices and services that we’re doing. It’s your app that gets to seamlessly plug into the Bing APIs and get software driven intelligences, bringing that soft AI into your app.
When you start thinking of your app are you realizing that this is the family that’s tightly coupled to right now, these are available to you? This will help you think what does it actually mean for you to have a delightful app? What exactly is your delightful experience? Most importantly moving forward this is what One Windows means to me. As you deploy your app that seamlessly has identity that seamlessly can leverage SkyDrive into Cloud that seamlessly brings in additional areas of intelligence. How it interacts in the domain of search, right, not just browsing but also seeking and sorting, decision making activities for your user, and pattern match, and productivity of course. How it leverages through and plays with Office and the Office Suite. How it can be used for personal expression, communication personal as well as social, and enterprise, right. Mobility, what exactly does mobility mean? Not just hand scale mobility but arm scale Tablet mobility, finger scale wearable and ubiquitous mobility, body scale mobility as you move into a car, the true nature of mobility, media and entertainment, right, passive, active, and social, gaming of course, serious and casual, and social.
This is the Microsoft world. This is the Microsoft eco-system and everybody’s trying to rush here.
Apples trying to rush here and Google’s trying to rush here, and we’re trying to rush here. We’re the ones best suited to deliver this. Our competitors aren’t even close. So many people right now are focusing on the ball of delight. The reason I joined Microsoft is because we are such good Lego builders.
We’ve been seeing this coming and we’ve building the infrastructure for this. But we can’t skip over delight. But if we can solve that, if we can get sustainable design here by investing in creativity, and we’re able to grow delightfulness from the inside out, we are all set to take over the future. It’s why I’m here. I believe in our stack. I believe in our design language. If we can get this, this is what I think what
Microsoft looks like to me. Thank you very much.
[applause]
Some people may want to break out. What I’m going to do right now is I’m going to fire up Visual Studio and I’ll walk you through a really quick example of using Cinder. But if some people did want to break out, if you want to stay in I was vacillating between doing it in JavaScript with Processing or doing it in
Cinder. But the descriptions said Cinder so we’ll fire that one up, and if you’re curious on that happy to show it to you, otherwise feel free to go into your breakout sessions or grab more pizza.
[demo]
Alright, so let’s see if we can get this working. We’re going to do one of those things you’re never suppose to do is live code. I do have a cheat sheet so let me pull that out. I probably should have tested the code before I brought it up. So the one thing if you want to get started on your own when you leave here just go and do a Bing search for Cinder Windows Store. You can also, if you do Cinder Windows
Store it pops up getting started with Cinder for Windows Store. You open this up, take us to our
Channel 9 MSDN code. While that’s going on just to let you know if you do a search for Processing JS

Windows Store it also brings in both the Codeplex Project and my series of tutorials in getting started on
Creative Coding with Processing JS for Windows 8 JavaScript, also on Channel 9.
But for Cinder we created with the community leaders a very detailed walkthrough of how to go through, download it off of Get Hub, setting it up, what exactly it means. This tutorial was written as much for you guys getting introduced to Cinder, but more importantly for us having a detailed walkthrough for the Cinder people working in other areas to realize hey you can start bringing your awesome onto our store. We’ve gotten rid of the roadblocks for you. That’s where we get to have really, really coolness.
So come into here again, Cinder for Windows Store or do Processing for Windows Store. But once you do get it you’ll bring in Cinder, you’ll switch to the DX branch because of course it needs to use a DirectX
Render. You’ll have a collection of tools here and one of them is called Tinderbox Windows. I know this isn’t the way we normally do things but this is the way Cinder does it, because Cinder has so many different users across so many platforms. They have a tool called Tinderbox that does all the C++ thinking for you. Again, although their coding in C++ most of these people do not consider themselves
C++ programmers. They consider themselves creative coders.
So they have these tools, things such as going deep into linking. The things that took me like weeks to understand before I could even compile my first C++ code, ha, ha. This is all about intelligent defaults, right. Getting those intelligent defaults, reducing those barriers so people can start playing and having fun first, and once they’re playing and fun, and invested, then they’ll learn what exactly they need to do as they start tweaking it.
So when you fire up Tinderbox, I’ll just create an application here. It’s going to be a Visual Studio 2012, by default I’m going to select WIN RT. Let’s hope this works. Okay, it creates a project for me with all of the linkings in here. I’m going into my Visual C++ 2012 WIN RT Project, open it up. Since I’m running
8.1, this works on 8.0 by the way but I’m just running 8.1 right now. It’s going to retarget it, no problem there. This is what Cinder looks like when you first fire it up. If you’re coming from Processing or even
XNA, or any of the creative coding languages it should look familiar.
There’s one important file here called Cinder Project App. If I open it up this is what I get. Now a lot of old school C++ people, which I’m not. I know a lot of you have been like writing C++ for ten years. I’ve been writing it for ten months so please don’t hold that against me. But this will open up and it kind of sets up. I have my class definition up here so I don’t even have to worry or conceptually understand this dot age versus C++. Not to get started just the very first one let’s just put it all up on here. Cinder has an abstraction library, has already given me the handlers for calling a setup mouse down, update and draw. So just like Processing, just like all the other languages Open Frameworks, just like XNA. This is how I think about sketching with code. I have a setup function, I have an update function, and I’ll have a draw function. It’s even gone ahead and clearing it out to black.

Let me switch this really quick to red to make sure that every things worked, please hope this works, otherwise the talks done. In C++ fashion, especially because I’m under debugging it’s going to take a bit of time. But there you go if you have a red screen in Windows Store, good, so at least we know
Tinderbox isn’t broken on Windows 8.1. Okay, coding and testing real-time live, so please bear with me.
So how do we start thinking about code? Let’s kind of walk through some basics. We already saw the ability of changing a background, color, talking to our DirectX context so all the heavy lifting of getting our context, talking to the GPU, that’s all done behind the scenes. That’s what an abstraction library should do. But let me come up here, let me start doing something interesting. So I’ll do a vec2f and I’m going to call this mouse, just leave this first right now. Under setup I’m going to instantiate my mouse equal to a vector, two dimensional vector of type float, going to zero it out, just good clean code. Under mouse down I’m going to have my mouse equal my events, get position which returns a type vector two. During draw first thing I’ll do is assign a color, I’m changing this back to black for right now so I can draw a nice red circle, RGB. So once I set my color for what my graphics card going to draw I’ll then say, there you go, draw solid color circle. It’s going to ask for a position so of course I’ll say mouse and a radius, we’ll just give it ten for right now.
If I run this, again we’re starting ugly and then we’ll slowly be weaning through delight. Hopefully I should get black; as I move my mouse I should have a red circle following it. It’s pretty much the hello world of, oops, because I had mouse down, sorry. Okay, so mouse down and it’s on touch as well. Okay let’s start making this a little bit more interesting though. If I wanted to add this to mouse move, right, and of course I’ve got to come up to my class and define that. Now that I’m here let me do vec2f and do position. As I move my mouse that red dots going to follow it. A lot of people are pretty much happy with that. I’ve always thought that’s kind of ugly, right.
But this is one of the first things, so Art Institute, teaching Flash or Silverlight, right Creative Coding or
Processing. This is just Creative Coding 101, one of the most basic ways to get setup. One of the first things you learn is how to procedurally add some easing. Because easing works a lot better on the eyes.
So, while we’re going to be drawing the circle in red, let me come over here and in green change color, draw solid color circle to wherever my position is also ten. If I do this right now, if I move my mouse the red mouse is going to follow, position though gets instantiated at zero but isn’t getting updated yet.
Let’s see if I run this, we’re going to have a fixed green and a red that follows my cursor. The rest of the magic’s all going to happen here in the update loop, so Cinder runs. Okay, I’m green, oops, this is supposed to be unset, there we go, thanks.
It actually was setting the pause 2D vector in my mouse move, that’s not what we want. So if I run this we will get green stationary, red moving wherever my mouse is at the speed of my mouse, and a lot of times we like to think oh that’s what people want they want to be really, really, snappy. But that’s not really an experience people are use to in the real world. So my green’s stationary, my red is moving as my mouse moves, but let’s add a little easing to this. There is a function that happens here really quick, let me double check.

Okay, these two lines of code if this is your first for intercreative coding this algorithm is your hammer.
You use this algorithm everywhere. It’s an easing algorithm. It’s basically the visual equivalent of Zeno’s
Paradox, right. It’s always where you want to be minus where you are times a fraction added to where you are. If you think about that Zeno’s Paradox, you know that you kind of walk out the door because there will be fifty percent, and fifty percent, and fifty percent. But by doing it as a percentage instead of a fixed set it gradually makes your steps get smaller and smaller.
This is the same thing. So while my mouse is going to be moving, immediately where my mouse is I’m figuring out the delta, basically where do I want to be at the mouse minus where I am gives me how far away I am. Then you need to times it times a percentage. That I’ll say okay twenty percent of the distance. So my first iteration I’m going to do a big jump. But since I’ve gotten closer my next iteration will be a little bit smaller, and a little bit smaller, and as I get really close it’ll slow down. This one algorithm and you can use this algorithm for anything, oops, sorry about that. Hope nobody saw that.
This is visually what it looks like. But you’ll be amazed once you realize that this algorithm exists and it’s out in the wild, and it’s how people do things. You see it everywhere because it’s what’s pleasant to our eyes. As I move my red, my green arrow slowly and casually starts following it. Because nature has taught us that these moves are organic. We start with gross motor movements and then we fine control down to eventually pick up the thing we want to do. So as we code into this, now it doesn’t have to be movement, we do this with sound, we do it with color, we do it with transparency. But this is like the killer algorithm for Creative Coding 101, remember this one. We’re going to get much more deeper than this but let’s go a little bit more.
Now that’s fine if you want to move circles, if you want to be finite. But let’s start moving it up a little bit better, you guys want more. Since this is C++ I was going to create a class, a CPP and header file for those of you coming from C++, but for those of you who aren’t don’t worry about. You can create a strut for some basic stuff. But for what we’re doing it’s totally fine. It’s like a mini object. So I’m going to create a strut called the dot, it’ll have a position, it’ll have velocity, and it will have life. Because I don’t want to just have the things moving with my mouse. As I move my mouse I want it to be dropping out these particles. We’re kind of doing this where we’re experimenting, right; it’s what creative coding is about. We’re experimenting, making mistakes, and that’s fine.
I’m also going to need to start including some files because it’s C++ that I’m going to be using. I’m going to do, include Cinder’s random function, include Cinder’s vector, and include C++’s vector. I’m going to want to start dropping particles as I move my mouse. So I’m going to have a vector that holds my dots,
I’ll call that M dots. So let’s do this for mouse down, that’s not good, well we’ll see. So here on mouse down, I don’t want to do it as I’m dragging my mouse. Again, we’re being experimental here. A lot of
C++ people go, ah, that’s very, that’s not a very optimum way of doing it. Its okay we don’t want to optimize too early, we’re just experimenting.
So I want to do something when I click on the mouse I want to start creating some particles. So let me do for anti equals zero, y is less than ten for right now, i++. So I’m going to create a dot, I’m going to

give it life. I’m going to have its position be wherever my mouse currently is. Its velocity, I want them all to have their own personality so I’ll create two dimensional vector. I’m going to call it my ran function and create a random floats. I want it to have the range from negative 6.0 to positive 6.0 for the X, and then the same thing for the Y. Most importantly, I’m going to throw it into my Array.
>>: [inaudible]
>> Rick Barraza: Oh, thanks a lot. Man, I’m so glad you guys are here, ha, ha. Good, make sense so far?
So little by little we’re building it up, mouse down going to create these struts, throw them into there.
We’re not going to be looking at destroyers or anything like that. Because really the type of overhead we’re looking at right now we’re just trying to make it cool. Then later on we can optimize it later, that’s fine.
So I’m creating these objects as data straight off of strut. Now under update we were already doing this stuff, but now let’s start doing this for the dots. Since it’s C++ I get to do my cool C++ tricks. So I get to iterate through all my objects in my vector, just like that. Every time it updates I’m going to update it to velocity. We’ll just leave it right there for right now. Okay, we’ll just leave it right there. We’re going to add much more to this to make it cool. Right now we’re just making it work. Then when we’re drawing we’re clearing out our stage here but, you know what let’s, I’m kind of tired of the black so let’s do a nice heather gray or so. Okay we want to draw the mouse and we’re going to draw the mouse. We’re going to start using some alpha transparencies and we’ll do some additive blend, it starts making things a bit prettier.
So we’re going to create a nice purple, half transparency. Let’s draw the follow and for him we will do a, let’s do a white; it’s also going to be an alpha though, so it’ll be a quasi opaque white. Now I’m doing all my stuff in drawing. Later on we’d abstract this out on classes, they’d have their own draw commands, and don’t worry about it every things fine. Also you’re going to be thinking about batching. MS Open
Tech guys already did this for you. The batching is taken care of on the backend. It’s already high, very optimized here. But we’re clearing out the window to a gray; we still have the mouse on follow.
But now let’s start visualizing our dots. For our dots we’ll type dot, this guy and all of these guys. You can tell I have all my C++ lingo down. Let’s be a little conservative. If life is greater than zero dot zero, now we want to draw them. Here’s something else we’re going to tweak a little bit later. But right now let’s just draw them red, well let’s draw them white, it will look a little ugly for right now but that’s okay.
Switching to white, draw solid circle wherever the position is, and we’re going to give it a diameter of
7.0. This will still be ugly but at least we’ll see if it works.
Oh, probably the important thing I didn’t show you, this is the glory of abstraction libraries, that’s all it took. I’m in Visual Studio, I’m targeting Windows Store Application, but because I have an abstraction library and all the references are done for me in Tinderbox this one macro is what flipped the bit for me.
All of this code, most of this code it’s just swapping out a GL namespace for a DX namespace and it works fine in any Cinder project you want. We go to the agencies that are doing the Kahn, that are

doing the such and such, that are winning the awards. They understand this code. This is how they think, this is how they explore, this is how they prototype. Now they can prototype on our platform.
Here’s what it is, normally this is render GL, MS Open Tech, and shout out to Dale Stammen, Atoberto
Fordesti, Mark Gaylor, and the entire team that made this happen. It’s right there; this is the one magic code that does it all. That does all the gunk in the backend. Again, I’m not a programmer, ha, ha, I’m a creative coder.
[laughter]
I’m thankful for Microsoft for doing this. So if we run this now we should at least start having the beginnings of something interesting. We changed the background to gray so that should be a little prettier. We added some coloring to the mouse and follow, see if that still works, okay, nice. The purple show where we are and eventually we’d just get rid of purple, but this is showing the point.
Now if I click somewhere, okay we’re shooting out black artifact. The visual artifacting I’m not sure what it is, it might be on the Windows 8.1 but we’ll check that out, so, pay no attention to the artifacting. But, okay so we’re getting here, we’re getting somewhere close. Let’s start adding some elegance to it.
Again reviewing the logic we didn’t even need to go through a full class because it’s just data right now.
We’ve created a strut, we have a vector that’s holding the strut. Every time we do a mouse down we’re creating ten data elements. Every time we call update we’re doing the very simple adding the velocity to the position which is why they keep going in a straight line forever. In under the draw loop besides drawing the mouse and the follow with this line of code we’re reiterating through all the dots, we’re seeing if they’re still alive. Of course they’re still all alive because we haven’t been dropping their life in the update loop. If you’re still alive color yourself black right there where we want you.
Let’s start making some fun things though. First of all let’s start, from the moment they’re born let’s start having them slowly die, so. We’re updating their position. What if we do dot, dot life because they start at one, let’s just have them slowly start fading out. Now since they’re starting at one of their life and slowly going to be getting down and right here we’re checking to make sure they’re above zero, if we do something like this, instead of black it should have been white. That’s full alpha, if we just say you know what let’s do the dots life we’re overloading their life which is moving from 1.0 to 0.0 as the alpha property for them. So with just this little change, as they move out they’ll slowly start fading away. So I got one, I click, oh, or they won’t because, ha, ha…
[laughter]
Right up here of course, there’s two things actually. There’s the enable alpha blending, which if you’re dealing with putting a lot of PNGs, putting a lot of graphics on the page that have alpha in them you need to flip this bit so that we know. Because remember this is highly optimized for you on the backend. So if you want the GPU to think about alpha then make sure you tell it. But we want to go one step further, instead of just alpha blending let’s do some additive blending. Additive is basically like in

screen mode if you’re in Photo Shop, mute two colors together they get brighter. It’s not just a question of alphas it’s a question of brightness.
So if we enable additive blending, which will also automatically give us alpha blending I hope. Good so we have a nice easing algorithm there which looks nice, ah, we’ll figure it out, it’s okay, failure. Oh, there we go, ha, ha. To some of the older guys…
>>: The life’s too long.
>> Rick Barraza: Start fading out, yeah the life’s too long. Also probably a good thing to note is I’m running in debug mode. Doing C++ doing this type of code in debug mode drastically drops your frames per second. If we switch this over to release mode and we run it. It has to rebuild for release mode but we’ll see a speed difference there. Although I don’t know how much because we’re not really even, we’re not even out of first gear with the type of stuff we’re doing here today. That’s okay I’ll show you some cool stuff right now.
So we have life, we’re giving the particles life, we’re taking that life into their visual account, but, and we have easing on the follow. But it’s still very Newtonian, it’s still very fixed. I click on it the particles are just kind of flying out. We can start experimenting and doing some cooler stuff, right. If we have life already we have this velocity and they’re storing a velocity. So we’ve taught you the Zeno’s Paradox, the easing algorithm. Here’s something else we can do. Their velocity, let’s do two things.
Let’s add a little bit of noise every time we update them. It will be a little bit so let me turn this down a little bit. So at first there’s very Newtonian velocity it was fixed. They’re born going a certain velocity but now every update loop their velocity is going to iterate a little bit. It’s going to pick a number between negative two to positive two for the X and Y, and add it because we’re adding to it, it’s going to get a little bit nuts. Sometimes it will accelerate it, sometimes it will slow it down.
But to really make it cool just because it takes so long to compile let me just kind of cut to the chase.
We’re going to add this little guy. These two guys together, free algorithm lesson number two for tonight. This little trick here adds a brownie in motion to your effects because you’re starting off strong in a certain direction, and every update you’re either going to push it a little further or hinder it a little bit more. But no matter what you’re always dampening back down that velocity, as if that object is moving through a liquid of some sort. Based on how much you dampen it down will determine the visual effect of what, how thick that liquid is moving.
So I run this now. I should really talk, compile then talk. I think that might be a little better, ha, ha.
Again I had years coding in C# and XAML so I’m still getting use to the compile times on this. But I love it, C++, DirectX, love it.
[laughter]

Ha, ha, I like job as well.
[laughter]
Good things, running through. It’s not moving around, I click on it, and start wandering out and fading out. I like your suggestion of the life taking a little too long. So let’s come back, again experimentation, exploration. So under life let’s…
>>: Do you change the path as well?
>> Rick Barraza: The what?
>>: Do you change the path as well?
>> Rick Barraza: Yeah, because it’s their velocity exactly.
>>: So velocity is used as a path as well.
>> Rick Barraza: So the position is always adding it’s velocity.
>>: [inaudible]
>> Rick Barraza: And so because of that if we’re tweaking the velocity we’ll…
>>: That’s right.
>> Rick Barraza: Be tweaking where its position is, right. That’s so that you can see the effect if I really force it back to zero faster it’ll make the viscosity of the platform seem more thick, because it will be more likely to go to zero. So you’ll see the kind of brownie in motion much more actively by forcing it to get to zero a little bit faster.
>>: [inaudible]
>> Rick Barraza: Oh, I changed this from .98, so it was just slowly always turning it down to zero. It doesn’t matter because the next thing it’s going to be pushing a little more.
>>: [inaudible]
>> Rick Barraza: The what?
>>: [inaudible]

>> Rick Barraza: Oh and then life also. Somebody said that it was taking too long life, hey that’s fine this is all about experimentation let’s speed it up. So I come through, I click, click, cool. Now probably one of the last things, oh here’s something else we can change. Since we have that life going from 1.0 to zero and since I’m already testing I’m not going to draw it if its life is less than zero. What if I just do this?
Let me turn this up a little bit at first. It’s not exactly my notes but we’re experimenting. So they’re going to start off at seven, this is their maximum health maximum life size, and as they get older they will both disappear and get smaller. Let me come up and let me slow them down a little bit more here.
I’m going to boost this guy back up to ninety-five. As you can tell most developers I’ve work with here at
Microsoft they love me because of my magic numbers. It’s like, ha, ha, magic numbers, joy, right. But really on creative coding it’s all about magic numbers at first. Once you understand what they are then begrudgingly I’m saying yes put them into constants and stuff like that. But a lot of us starting on Flash it’s like hey it works, it looks cool, works on my machine.
So moving it through, click, and you see them slowly get smaller and fade away. So it’s looking kind of pretty. So one thing we can do, okay I like that effect, start cranking it up to eleven now. Last thing we can do is this guy right here. We’ve been making them white. We have a nice gray, we have a nice white, we have a nice purple, but the particles it’s a little bit boring so what if we start tweaking their color based on their position on the screen? So whatever your current position, so again remember color alpha it’s RGB. We’ll always keep the green turned all the way up, that’s fine. But we have their X and Y position as an input for our draw command. If we have it as an input let’s start experimenting; let’s just start tweaking and see what happens.
So I’ll do wherever your position is, this has to be from, has to be normalized. So we need a way of finding out what the Windows screen is. Thankfully Cinder is good at that. Oops, position dot Y, so wherever you are on the screen divided by however high the screen is that’s my normalized value of zero to one, that’s your R value I want you to have. Now just do the exact same thing for my blue value except instead of height we’ll do width. Our X position divided by our Y position, and probably the last thing here is ten seems so boring; forty-two is what we really want. Because that’s really the life, the answer right to life, the universe, and everything.
So now if we test this, I think for this particular sketch that we kind of started free forming and I did do this one free forming yesterday. I printed out some of the code because, ha, ha, I’m not dumb. I wanted to at least have it tested once before. But this is just what creative coding looks like. We’re trying things in; we’re throwing them on there. We’re doing it in C++, right; it runs out, it’s a lot of running and testing.
This is what sketching looks like. Bill Buxton also to misquote him again and I apologize again. Sorry our follower, if we click it up, up here a very low X, very low Y so it’s very green but as I start moving down the screen, well a very high red and green but no blue makes yellow, click on over here. The red gets turned down but the green and blue is turned up. Of course as we come down here every thing’s full

throttled all the way up to one so of course we get white. So something like this is kind of cool, right.
From here you just go on and experiment and do whatever you want. But let me go back to kind of show that. I really wanted to emphasize this so hold on. There we go.
I really wanted to say under a hundred lines of code, under a hundred lines of code, ha, ha, in C++ we’re coding against the GPU with pre-built graphics and colors, with one line commands. Loading a texture and I won’t show this today. Let me show you a couple other, no not code now, but let’s kind of see some of the things. So that was our example. If you download getting started with Cinder on Windows
Store, I wrote the DirectX samples. These are some of the samples that I wrote out to the community so they can start seeing what’s possible with DirectX on Windows Store.
Here’s Hogins Particles which is a common demo on Iwes. So it’s kind of what we were doing but you can see this texture. It’s now drawing PNGs that are glowing and we’re getting that effect. That’s the main thing; it’s still off of the PNG. More importantly though, so let me keep going to the quad counts that we’re having. Obviously this is slightly more optimized code but not that much more. See our quad counts up there, our frame rates a nice sixty frames a second. Let’s start loading it up though. What if we add gravity? Okay, well now they start falling. That’s cool, if they’re falling let’s maybe add a floor.
Oh, that’s cool. Let’s kind of visualize that a little bit. Let’s add some tails to it, oh, okay, nice.
It’s still very Newtonian that’s not a little bit, we were doing like cheap perlin because it’s where it’s actually more brownie in motion. But there’s an entire perlin function already baked into Cinder so I add perlin to the velocity and now we get, now we start getting the types of examples. As you can see additive blending is turned on so as they overlap they get wide and bright, right. These types of things and of course touching and point, so I’ll point integrated, and you’re single point right now but we have other examples from multipoint.
That’s pretty cool. This is the type of stuff people have fun with. We go to students, we go to academy, we go to MIT, we go to Parsons, we give them a Surface Tablet. We say that Cinder that you’re using on here it’s already preloaded, right. Here you have Windows 8, here you have Visual Studio 2013, here you have the temp off of Tinderbox, you can start playing on our Tablet. By the way do you know that we support Multi-touch?
Alright, by the way we start bringing in a couple more brainiacs if you, since we are using DirectX, do you know that DirectX 11.1 allows stereoscopic output? Blew your mind, what IPad doesn’t have it, what?
We have it out of the box on Windows 8. Nobody touches it because DX is hard. It’s hard to learn C++ and DX. We don’t have any abstraction libraries. This is an abstraction library for C++ DX, right. They can start getting it. They can start playing with. They can start getting excited about our platform.
Most importantly we’re bringing fun back to our platform.
Here’s another example. This was like again under a hundred lines of code, grabbing an image, iterating through their RGB values, creating a point cloud of the color value, then offsetting that mesh in Z space based on the brightness of the screen, right. Again simple, dumb examples, C++, DirectX, I personally

like this one quite a bit. This is the stuff people play with. This is what artists want to play with. We have this now on our platform with Cinder but there’s a little bit more. We’re trying to get Open
Frameworks that’s the big one. Trying to get Full Processing Support over on our end, but that’s what it looks like.
Again, thank you I went a little bit more over time. I just really wanted to show you that code. It’s on there, search Cinder for Windows Store, you can get started. I’m ricbarr@microsoft.com
or
@rickbarraza. Happy to help you guys out. Let’s just get this mute out, right. We’re in such a good position we can bring fun again, make coding fun for Windows Store. If we do that we’ll get creatives. If we get creatives we’ll get good design, and if we get design everything will be delightful, right.
So again, second thank you for the evening, I appreciate it.
[applause]