You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Building an Amazon Echo (Alexa) skill is extremely simple, if a bit cumbersome. If you're not familiar, the Echo is an always-on home automation unit with built-in support for things like playing streaming music, getting weather information, and even turning on your wifi-connected lights. Amazon also allows developers to extend the Echo's functionality with custom "skills". These skills get the benefit of Amazon's full speech analysis engine and works through a simple JSON web API. In this talk we'll cover how we can use Node.js to write a simple skill and what else we need to do to get up and running. You'll learn how to test your new skill with a real voice interface and the basics of the cumbersome setup process on Amazon's developer portal along with some best practices. You don't need to own an Echo to write a skill... although they sure are fun to play with!
300 Characters
Building an Amazon Echo (Alexa) skill is extremely simple, if a bit cumbersome. Skills get the benefit of Amazon's full speech analysis engine and operate through a simple JSON web API. This talk will show how to use Node.js to write a simple skill and what else we need to do to get up and running.
450 Characters
Building an Amazon Echo (Alexa) skill is pretty simple, but a bit cumbersome. Skills get the benefit of Amazon's full speech analysis engine and operate through a simple JSON web API. This talk will show how to use Node.js to write a simple skill and what else we need to do to get up and running on Amazon's developer portal. Attendees will also learn how to test their new skills with a real voice interface. (No Echo device required!)
Asynchronicity is fundamental to JavaScript and a huge benefit for web and API development, but for too long developers have had to struggle with difficult to follow logic and code that quickly becomes untestable and unmaintainable. Promises were a stepping stone toward a better workflow, but they don't solve the problem by themselves. This session will cover the basics of Promises and two methods for making asynchronous workflows simple to follow and maintain: generators and async/await. Both are new to JavaScript in ES6/2015, but available through libraries or preprocessors as well for older environments. We'll look at some use cases and see how these structures can be used to solve problems. Coming out of this session, developers will have a greater understanding of how to structure their asynchronous code.
410 chars
Asynchronicity is fundamental to JS and a huge benefit for apps and APIs, but developers have had to struggle with difficult to follow logic and code that quickly becomes unmaintainable. Promises were a stepping stone, but they don't solve the problem themselves. This session will cover an intro to Promises, and then how we can use them to build better asynchronous workflows with generators and async/await.
Old version
Chrome, Firefox, Node - even Microsoft Edge - all of these have added basic support for generators, but this area of JavaScript is still shrouded in mystery and inexperience. Generators allow developers to write functions which can be paused and resumed at will. When used well, this can create much simpler asynchronous workflows and avoid callback hell without the need for complex structures such as Promises. In this session we'll dive into generators and the 'yield' keyword to show attendees what they are, and more importantly why they should care! We'll look at some use cases and see just how these structures can be used to solve problems. Coming out of this session, developers will have a greater understanding of this new feature in ES6/2015 and what's coming next!
We all know you need to test your JavaScript code, but now that you are, how do you automate the process? How do you take your testing from the browser to an automated solution with cross-browser execution? How can we make this whole process easier? This talk will walk attendees through the process of setting up test automation using some basic tools...
It's finally happening: JavaScript is growing up and browser vendors are on board this time. But most web developers are stuck in the year 2000 when it comes to JavaScript. In this session attendees will get a good look at some of the more compelling - and practical - changes already in their favorite browsers. We'll talk about new variable declaration types and scopes with let and const, default function arguments, object deconstruction, template strings, "classes", Promises, and more. This will be a whirlwind tour, but with practical examples and information that every web developer should have.
Can you really use these features? Our last topic will be browser support and how to transpile ES6/2015 code down to ES5 for use in older browsers. This is not an introductory session, so attendees should come armed with a basic understanding of JavaScript functions, scope, and async programming!
300 Characters
JavaScript is finally growing up! But now we need a primer in some of the more compelling and practical changes. This session will cover variables and scope, modules, template strings, "classes", and more. It will be a whirlwind tour, but with practical examples and info every web developer needs.
450 Characters
JavaScript is growing up and browser vendors are on board! But many developers are stuck in the year 2000. This session will show attendees some of the more compelling - and practical - changes in ES6/2015. We'll talk about new variable declaration types and scopes, default function args, object deconstruction, template strings, "classes", and more. This will be a quick tour, but with practical examples and info that every developer should have.
Tutorial
It's finally happening: JavaScript is growing up and browser vendors are on board this time. But most web developers are stuck in the year 2000 when it comes to JavaScript. In this session attendees will get a good look at some of the more compelling - and practical - changes already in their favorite browsers. We'll build a small application using these new features and no external libraries! Topics covered in our project will include new variable declaration types and scopes with let and const, default function arguments, modules, object deconstruction, template strings, "classes", fetch, Promises, and more.
Can you really use these features? Our last topic will be browser support and how to transpile ES6/2015 code down to ES5 for use in older browsers. This is not an introductory tutorial, so attendees should come armed with a basic understanding of JavaScript functions, interacting with the DOM, scope, and async programming!
Using Open Source Government Tech to Solve Problems
Government agencies produce, store, and provide open access to hundreds of thousands of datasets. Teams within the General Services Administration (GSA) create reusable components not just for other agencies, but for everyone to use. Are they perfect? Of course not, but they serve a vital role in iteratively improving the public's access to data and services.
In this talk Jordan Kasper will discuss how he created a website built on top of those tools and data to solve a real world problem. He'll cover how to discover open datasets and APIs, give an intro to the US Web Design System, talk about open source software in the federal government, and show how every one of us can help improve civic technology for the greater good.
Having trouble groking Git? Not sure what the difference between merging and rebasing is? Wondering what you would ever use a "cherry-pick" for? We'll cover these topics and more in this talk, helping attendees get past Git novice and on their way to Git master. The talk will begin with a short overview of git fundamentals, but quickly jump into more advanced concepts. We'll cover branching, commit amending, stashing, cherry-picking, and yes, merging versus rebasing. You might not be a Git guru after one conference session, but you will have a better understanding of how to play nicely with others in the same Git repository and how to fix common (and not so common) issues in Git.
Short Version
Having trouble groking Git? Not sure what the difference between merging and rebasing is? Wonder what you would ever use a "cherry-pick" for? We'll cover these topics and more in this talk, helping you get past Git novice and on your way to Git master. This is not an introductory talk, come prepared to put your existing knowledge of staging, committing, and basic version control to the test!
Tutorial
You've taken the plunge and your organization is fully immersed in Git... Great! But now the hard stuff starts creeping in. Your team is growing, becoming more diverse and distributed. It's time to level up. This tutorial will walk attendees through a number of real world scenarios and how they might be handled using Git on the command line. This is not an introductory workshop, so come prepared with some basic understanding of version control with Git including staging (adding), committing, pushing, and pulling changes. We'll cover many topics including branching strategies, amending commits, resetting, using the stash, cherry-picking, and merging versus rebasing. Attendees will come out of this session with a better grasp of how to use more advanced features of Git and some new strategies to take back to the office.
Older version
Having trouble groking git? Not sure what the difference between merging and rebasing is? Wondering what you would ever use a "cherry-pick" for? We'll cover these topics and more in this talk, helping you get past git novice and on your way to git master.
We'll do a short overview of git, then jump into:
branching & workflows;
commit amending;
merging and rebasing;
cherry-picking;
pull requests;
stashing; and
tags
Okay, maybe you won't be a guru after one conference session, but you will have a better understanding of how to play nicely with others in the same git repository.
Grunt makes building JavaScript, Sass, HTML and any other front end code dead simple. It is quickly becoming an indispensable tool among front end developers because it can fit into just about any build or continuous integration system. In this talk we'll bring developers up to speed on how to get it running and integrated with your project. We'll quickly move onto some core tasks that should appeal to every web developer out there.
Specific topics include:
Installing Grunt (CLI and in your project)
Installing Grunt plugins (Node modules)
Adding and configuring common tasks
Combining tasks to form build commands
Tutorial
Deep Dive into Grunt
Grunt makes building JavaScript, Sass, HTML and any other front end code dead simple. It is quickly becoming an indispensable tool among front end developers because it can fit into just about any build or continuous integration system. In this talk we'll review basic Grunt setup and configuration and then quickly move into more advanced concepts. This is a hands on class that will get attendees up to speed on utilizing Grunt for more robust build environments.
HTML and JavaScript have come a long way since the dark days of IE's domination of the browser market. In this talk, Jordan Kasper will introduce you to some of the exciting new features in HTML5 that we can implement right now in our applications! We'll look at capturing the user's camera data, accessing their location, reading the file system, native drag and drop, and even vibrating their phone! Join us for a session of fun demos and new experiences. Attendees will walk away from this session with some ideas about how to make your web applications even more amazing with these new APIs.
We all love jQuery - it's easy, efficient, and there's tons of information online to do just about anything. But with that mass of information comes confusion about how to do certain things. When you want to abstract some of your code into a plugin, how do you structure it? How do take in options, and how do make sure you don't break the the way jQuery works? And when you're done, where do you put it and how do you get it to the masses?
This talk will run through some of the basics and guide you in the right direction. In particular, we'll cover:
structuring your plugin code
making your code testable - and testing it!
tracking your code on github and getting on the jQuery plugin site.
Lessons Learned from Teaching Git Over and Over and Over
Many of us believe that Git is universal, that everyone knows Git, until you onboard a new team member that doesn't.
Teaching Git is non-trivial... even to seasoned developers (sometimes especially to seasoned developers). In this session we'll review some of the common areas that trip up new Git users through a case study in teaching Git over and over at an immersive code school. Attend this talk if you want to explore what topics to focus on, where developers get hung up the most, and how to properly communicate the core concepts in Git.
In particular, we'll discuss issues around what is a commit, and what happens when we push them, including the nature of a distributed source control system. Then how to explain a "merge", and how branches work. An important aspect of that is learning the workflow of an organization and being able to follow it.
How many mobile devices do you own? Two? Four? And how many devices do your users as a group have? Twenty? Fifty? Web developers have long relied on local browser testing - maybe on a couple machines - to ensure their CSS and JavaScript code is up to snuff, but that just won't cut it any longer. This talk will introduce attendees to the new testing paradigm for the mobile web: emulation and virtual environments. We'll talk about looking at your mobile site in multiple environments as easy as you can multiple browsers on your desktop using tools such as Browserstack. We'll even talk about automating your tests (you are writing tests, right?).
Attendees will come away with a knowledge of the various tools available and how to begin implementing them into their development workflow.
One of the hardest parts of any front end testing strategy is eliminating dependencies; in particular, your own server and data source. This talk will introduce attendees to the problem, why it's important, and how Ajax mocking can make their lives easier. We'll also cover a couple of methods for mocking out server requests using jQuery and Angular. Attendees will leave this session ready to test their front end code without waiting for any back end code to be finished, speeding up development time and reducing headaches!
Angular Primary Version
Mocking a Server for Angular Testing
One of the hardest parts of any front-end testing strategy is eliminating the dependency of a back end to serve up the data. Angular makes this process extremely easy - if you know what to look for. In this talk we'll cover how to use the Angular mocks module to create a dynamic and easily managed mock back end for your API. That includes hooking it up to your application module and making sure your unit tests are hitting it. Developers will leave this session ready to mock out any Angular HTTP call in their application for testing.
One of the most difficult pieces of the front-end testing puzzle is having to work with (or rather, without) a server. Testing JavaScript code should be able to be done in isolation, and the jQuery Mockjax library allows developers to do just that. In this talk we'll cover what Mockjax is and how it can help you write better tests by mocking out Ajax calls without touching your application source code.
After introducing the library and basic usage, we'll dive into more advanced topics such as dynamic request matching, simulated latency, mocking server errors, and using external services or files as proxies. Developers will come out of this session with a tool they can use to enhance the idempotence and atomicity of their front end tests.
Alternate: Node.js: The 800-pound Gorilla in the Room
It's new, it's shiny, it's what all the cool kids are talking about... now it's time for you to take a closer look at Node.js. In this session we'll cover some of the basics about how Node operates, what a module should look like, and how to structure an application. We'll also talk about when it might be appropriate to use Node.js and how it can supplement other technology stacks. You won't be an Node expert after one session, but now you'll know what all the hype is about, and what the next steps might be.
businessy
Node is just JavaScript they said. All you need is basic JS skills they said. They were right! And like it or not, it's making big headway in the web industry with large organizations integrating it, or shifting entirely. In this talk Jordan Kasper, developer evangelist for StrongLoop will cover what Node is, how it relates to the API Economy, and why you should care. APIs are changing the face of technology and Node is playing a big part of that transformation. Waiting to see what will happen is no longer an option.
CIOs, CTOs, and developers of all levels will come out of this session with useful information and how to approach the 800-pound gorilla that is Node.js with no fear. They will learn about what Node is, and how it relates to the new idea of the "API Economy".
Object-Oriented JavaScript (yes, it really exists)
What's that you say? You don't like working in JavaScript because you can't code like you want to with capital "O" Objects all over the place? Sure you can. More and more people are starting to realize how powerful this little language can be - start your re-education with this session and learn all about OOP in JS. First, we have to accept that while JavaScript may exhibit some characteristics of a functional language, it is really a multi-paradigm language with strong support for Object-Oriented Programming concepts.
This talk will give attendees a crash course in Object-Oriented JavaScript covering:
core OOP principles
the prototype object and constructors
member access types (public, private, & privileged)
prototypical inheritance
interfaces (mixins)
Developers will come out of this session ready to implement core OOP concepts in JavaScript, with knowledge of how inheritance in JavaScript differs from many of the other languages they know.
Shorter Version
"But I thought JavaScript was a functional language?"
It can be... but JavaScript has a powerful object model that has been there all along, just not one that you're used to. Let's start your re-education with this session and learn all about OOP in JS. I'll give attendees a crash course in Object-Oriented JavaScript covering the prototype object and constructors, member access types (public, private, & privileged), prototypical inheritance, and interfaces (mixins).
Developers will come out of this session ready to implement core OOP concepts in JavaScript.
Knowing how to write proper SQL is good, and that database utility class you wrote works great - but as the old adage goes: you shouldn't rediscover sliced-bread ... or something like that. This talk will introduce attendees to Propel - an open-source Object-Relational Mapping (ORM) library for PHP - that will make your life a lot easier. An ORM can significantly reduce development time by mapping your relational data into PHP objects (and vice versa).
This talk will cover:
generating database tables and an object model
validation and extended behaviors
basic CRUD using ActiveRecord
using the ActiveQuery to find records
Attendees will come away from this session with a solid understanding of the open source Propel ORM, how to integrate it into their project, and how to get started quickly using the framework.
The key to understanding JavaScript's object model is understanding the prototype object. This talk will guide attendees through the prototype: how it is created, what it is, and how to use it in object-oriented JavaScript. We'll then dive into the prototype chain and how it allows JavaScript to support inheritance. In addition we'll cover some related OOP concepts like constructor methods, accessing parent methods and properties, and even the new ES6 class keyword. By the end of this talk attendees will have a good core knowledge of JavaScript's prototype object and how to use it in object-oriented programming along with the new syntactic sugar that ES6/2015 provides.
450 Characters
The key to understanding JavaScript's object model is understanding the prototype. This talk will guide attendees through the prototype object: how it is created, what it is, and how to use it in object-oriented JavaScript. We'll then dive into the prototype chain and cover some related OOP concepts. Attendees will learn about basic OOP in JS, but also how ES6 provides new syntactic sugar over the complexities of prototypical inheritance.
"Story" Version
One day an ambitious JavaScripter decided to write some object-oriented code. "But JavaScript doesn't have a robust object framework!" cried the coder. Just then a canonical Dog object appeared and informed her that understanding JavaScript's object model requires an understanding of the prototype object. "What is this magical item," she asked. "It's not magic," replied the Dog, "it's just another object." He went on to explain encapsulation and polymorphism, the constructor method, and even interfaces (or "mixins"). By the end of the conversation the now-well-informed JavaScripter felt prepared to implement OOP concepts in her code and understand what all of those frameworks are trying to do. The Dog even gave her a glimpse of the future with ES6 classes!
/^[Rr]eg(ular\s)?[Ee]x(p|pressions?)?$/
Finding Your Inner Regex
Regular expressions (RegEx or RegExp depending on whom you ask) exist in a mystical, magical wonderland that many developers avoid like the plague. This talk aims to demystify this extremely useful and powerful tool. We'll talk about what regular expressions are, why we want to learn them, and the basic ins and outs of matching text and seeing those results. There are a lot of concepts in this tool, but this talk will hit the basics: character classes, grouping, escaped characters, flags, modifiers, and more. While not every language implements regex the same, this talk will give attendees the foundations they need to work in any language.
30 chars
Regular expressions exist in a mystical, magical wonderland that many developers avoid like the plague. This talk aims to demystify this useful and powerful tool. We'll talk about what regular expressions are, why we use them, some basic concepts, and some new ones for developers of any level.
More and more companies are realizing that there can be great benefits in allowing knowledge workers to telecommute - and developers are dancing in the streets. But what are they actually doing at home? Do they put on pants? Are they working their required 8 hours each day? Are they actually at their desk when you have a conference call? We'll chat about why these are the wrong questions to ask and what to expect both as a remote worker and manager. Whether they're currently working remotely, want to, or have to manage these people, all attendees will walk away knowing what the right questions to ask are within their teams. I'll make a few confessions and we'll see why it's okay to play a game of minesweeper here and there.
Shorter Version
Many companies now realize that there can be great benefits in allowing knowledge workers to telecommute, but what are those workers actually doing at home? Are they at their desk 8 hours a day? Do they put on pants? We'll chat about why these are the wrong questions, I'll make a few confessions, and we'll talk about what to expect as a remote worker and manager.
Longer Version
Do your remote employees put in all of their hours? Are they tweeting while working? .....
Longer Version (old)
The benefits of allowing knowledge workers to telecommute are being recognized more and more by companies large and small across the globe. These are people whose main working capital is knowledge, and who generally tackle non-routine, problem solving tasks day-to-day. This small shift is being heralded in the developer community and, to some degree, by company executives who see benefits to their bottom line. But there is a lot of confusion about what a 100% remote environment looks like - both to the worker and to management.
In this talk we'll cover some of the common misconceptions about remote working, what a real, day-to-day environment might look like, and chat about why many managers focus on the wrong metrics when trying to evaluate the success of remote workers.
I'll make some confessions, we'll talk about proper attire, some essential skills for remote workers, and why it's okay to play a game of minesweeper here and there.
Shortly after it arrived at his home in 1993, Jordan began disassembling his first computer - his mother was not happy. She breathed more easily when he moved from hardware into programming. Jordan's experience includes development, instruction, and mentorship at startups, agencies, Fortune 100 companies, universities, the Federal Government, as well as numerous open source projects. He speaks regularly at (and helps organize) local user groups and conferences big and small. Jordan's primary mission for over 15 years has been to evangelize technology of all sorts and share what he has learned to help others grow. As a member of the United States Digital Service Jordan currently works on helping transform technology at the Department of Defense. In his down time he enjoys puzzles of all sorts and board games!
Gov Version
Jordan Kasper started programming in 1993 and has developed systems on platforms ranging from IBM mainframes to TI calculators and everything in between. His professional experience ranges from startups and digital agencies, to Fortune 100 companies and government institutions. He is currently a Senior Advisor for Technology at the Department of Homeland Security where he helps to reform struggling software programs, advocate for modern tech and practices, and push advise on policies and strategies. Jordan is an open source software advocate, community organizer, conference speaker, and board game enthusiast.
100 Word Version (< 600 chars)
Shortly after it arrived at his home in 1993, Jordan began disassembling his first computer - his mother was not happy. She breathed more easily when he moved from hardware into programming. Jordan's experience includes companies large and small, universities, the Federal Government, and various OSS projects. He helps organize and participates in user groups, conferences, and other events. Jordan's primary mission for over 15 years has been to evangelize technology of all sorts and share what he has learned to help others grow. In his down time he enjoys puzzles of all sorts and board games!
Less Technical Version
NEEDS UPDATE
Jordan has been developing software since 1993 at the age of 13. His experience includes numerous startups, Fortune 500 companies, and world class universities. His primary focus for the last decade has been elevating web applications beyond their desktop counter parts. Remote working has become a way of life, allowing Jordan to travel the world and speak at conferences large and small. His conference talks focus on web application development and virtual work places. In his down time he enjoys puzzles of all sorts and board games.
Businessy
NEEDS UPDATE
As a Developer Evangelist for StrongLoop Jordan focuses his time and energy on sharing and teaching the joys of JavaScript, Node.js, and StrongLoop's API lifecycle software. He has been developing applications since 1993 starting with BASIC and C++. His experience prior to StrongLoop includes numerous startups, enterprise companies, and universities. Jordan regularly organizes and speaks at usergroups, barcamps, hackathons, and conferences around the world on all manner of technology. In his spare time he enjoys board games and puzzles of all sorts.
First Person (may need edits)
I have worked for companies large and small, including startups and a large university; I am a contributor on a number of open source projects and regularly participate in community events. Teaching and speaking is a way of life, and I love evangelizing the good technology and traits I've found over the years. My primary technologies are PHP and JavaScript (and all of the supporting technologies around them). In my down time I enjoy puzzles of all sorts and board games.
140 Characters
Hacker, puzzler, developer, JavaScripter (and I've been called worse). This is what I do, and what I love. I've been doing them all my life.
Stop eyeballing your UI in a browser to test your JavaScript code - that doesn't count. While many developers have embraced testing in their server side code using TDD, fewer test their front end JavaScript code in the same way (or in any way), and even fewer of those use any kind of automation. This talk will guide attendees on how to write testable JavaScript code, how to write tests for that code, and some solutions for automating the process.
Participants will come out of this talk ready to implement and automate better tests for their JavaScript code.
Angular Version
Stop eyeballing your UI in a browser to test your JavaScript code - that doesn't count. While many developers have embraced testing in their server side code using TDD, fewer test their front end JavaScript code in the same way (or in any way), and even fewer of those use any kind of automation.
This talk will guide attendees on how to write testable code, how to inject dependencies in their tests, and how to automate the process. We'll use some common tools to get you started, but all concepts presented will transfer to just about any testing framework or automation tool the developer likes to use.
Tutorial Version
While many developers have embraced testing in their server side code, far fewer test their front end JavaScript code in the same way (or in any way), and even fewer of those use any kind of automation. This tutorial will guide attendees through the process of writing testable JavaScript code, setting up a testing framework, writing tests for that code, and some solutions for automating the entire process. We'll talk about some common issues such as asynchronous tests, anonymous functions, and automating tests that would normally require browser interaction.
Participants will come out of this session ready to implement and automate better tests for their JavaScript code on their own. They should come into this session with a solid understanding of basic JavaScript including basic variables, calling and writing functions, using callbacks, etc.; however, advanced knowledge is not required.
Skip The Rewrite. Take Your Web App Native in Windows 8
You've written an app for iOS and Android... you don't really care about Windows 8, but the boss wants something in the Windows 8 app store. But wait, Windows 8 can run native HTML, CSS, and JavaScript apps! Wouldn't it be great if you could just reuse your awesome HTML5 & JavaScript web application for your native Windows 8 app?
This is exactly what we built for Microsoft - the Web Application Template (WAT). What the WAT? This is a new, open source framework created by Microsoft that wraps your web application with native Windows 8 JavaScript libraries letting you utilize many of the native features without having to write another native application.
We'll demo creating a new app in this framework, but then dive deeper to see how it's built and how easy it is to extend it using your existing toolset. Attendees will leave this talk with everything they need to create and deploy a Windows 8 application in less than a day.
Original
You've written an app for iOS and Android... you couldn't care less about Windows 8. Problem is, your boss wants a presence in the Windows 8 app store. Wait, didn't you hear something about Windows 8 running HTML, CSS, and JavaScript natively? Wouldn't it be great if you could just reuse your awesome HTML5 & JavaScript web application for your native Windows 8 app?
Enter the Web Application Template (WAT). What the WAT? This is a new, open source framework created by Microsoft that wraps your web application with the native Windows 8 JavaScript libraries letting you utilize many of the native features of Windows 8 apps without having to write another native application. The Web Application Template allows a developer with just a little JavaScript, HTML, and CSS knowledge create a great looking native app with minimal effort.
We'll demo creating a new app in this framework, but then we'll dive deeper to see how it's built and how easy it is to extend using your existing toolset. Attendees will leave this talk with everything they need to create and deploy a Windows 8 application in less than a day.
400 Character Version
Windows 8 offers yet another app store to get your product out to consumers, but who has the time to write another native application? Don't waste your time, Windows 8 can run HTML, JavaScript, and CSS natively! This talk will introduce you to the Web Application Template (WAT) - a new, open source framework that let's you create a native Win8 application wrapper around your existing web app.
How popular will the WAT framework be by the time this is submitted? I'm assuming not very so some comparisons might help people get a better understanding of what to exactly to expect. Maybe a short like PhoneGap but better… I like the title and the abstract sounds good to me.
@jwoodcock Good point, it will not be popular as it is very new... really just being released in the next few months. That said, Microsoft is going to start pushing hard to the developer world (so I've been told). I'll think about the comparison idea...
OO-JS
The second paragraph seems like it would benefit form being a bulleted list.
Bio looks good. :)
=C=