Don't be intimidated by Functional Programming. It is hot! And worth the effort! Take advantage of multiprocessors. Write fewer tests. Have more confidence in the correctness of your code. I will give you an introduction to Functional Programming in Clojure that will provide a firm footing for future exploration.

How do you write large applications in JavaScript? Can it really be done? Like you would in any language, you break the large app into several small apps that communicate in a structured, predictable manner. Proper de-coupling is the key. In this session we'll cover the journey from spaghetti code, to introducing the observer pattern for first level events, and eventually introducing the concept of 'messaging' in JavaScript. We'll talk about the strengths and weakness of these approaches, some recommendations of when to use what, how powerful they can be in tandem...and have some fun looking at a completely ridiculous sample app utilizing messaging and events across frames and workers.

In this “demo-tastic” presentation, SSIS trainer, author, and consultant Andy Leonard explains the what, why, and how of an SSIS framework that delivers metadata-driven package execution, connections management, and centralizes logging. Key takeaways: 1) Developers can migrate packages from Development, through their lifecycle, to Production without editing SSIS Connection Managers properties. 2) A metadata-driven approach to SSIS package execution. 3) Demonstration of a centralized logging reporting application. Objectives: 3. An introduction to Design Patterns-based development. 2. Real-world demonstrations of applying patterns-based design to data integration requirements. 1. Increase data integration solution quality, increase maintenance and management efficiency, and learn a process to deliver repeatable, stable, and audit-able data integration solutions.

You have invested countless hours mastering MVVM in XAML, in fact you might even consider yourself a XAML Ninja. Sadly, XAML is so last year. Html/JavaScript/Jquery is now the new 'It Technology Stack'. Fear not because all your Ninja skills are not lost because KnockoutJs is a killer MVVM library for Html/JavaScript. In this session we are going to learn how to transfer your XAML Ninja skills to the wonderful world of KnockoutJs. This session will be done in the 'hey, in XAML it works this way and in Knockout it works that way' format. By the end of this lesson you should feel comfortable with making the leap from XAML to Html.

Why would you want to build both your wesbite and then repeat much of the same code to add on an API? Using the open source ServiceStack.NET project you can easily build both a website and web services with a single set of code. We will build a Razor based site that embed standards compliant web services that return any number of response formats including JSON, POX and SOAP. Even better, all of this runs on Mono so you can host your application on a number of different platforms. In addition we will review the ServiceStack.NET client that allows you to call the services with almost zero effort on any platform that supports .NET or Mono including Android and iPhone.

Using User Defined Functions in your database code is like playing Russian Roulette with 5.97 bullets in the gun!! There are SOOOOO many ways they can kill you: staggering performance degredation, tempdb allocation issues and bad data!! Oh, did I mention performance issues?? Those include row-by-row processing under the covers, bad estimates leading to horrible query plans, voiding parallelization in the engine, etc. In this jam-packed session we will cover all this and also discuss several ways you can get rid of them.

In today's software world, the app is king. And with apps becoming ever more essential to today’s business, entertainment, and personal life, it almost goes without saying that any new development project or consumer product will eventually need to target multiple clients on multiple devices. As a developer who may end up writing for the phone, tablet, web, and desktop, it can be critical to make the correct choices up front in terms of your team's development patterns and application architecture. In this one-hour session, we will discuss some of the pitfalls faced by teams today. Particularly for apps that are already in production, what limitations may there be to extending for the mobile and tablet world? And if you are building from the ground up, what choices do you have to create a robust, flexible, accessible server and API that can be used by your own client app dev teams, as well as third-party API consumers who can extend your brand even further. Our technical focus will largely remain agnostic to your chosen database technology, SQL (or NoSQL), and other back-end logic. Instead, we will look at the services and client tiers. The discussion will weigh the pros and cons of WCF Data Services (with JSON endpoints), as well as building RESTful services with the newer MVC 4 Web API. Client-side technologies could be anything, but we will certainly consider at least clients for the web, iOS (via MonoTouch), and possibly XAML/WinJS for Windows 8.

Microsoft Test Manager helps testers define and execute system test cases. These tests can be executed as exploratory and scripted test cases and you can use action recording to manually re-play test cases in the future. But it doesn’t stop there!Coded UI Tests help your teams leverage manual test cases by automating them and then they can be executed as part of your builds. We will cover the following: - Create a test plan and test cases - Create an action recording for a test case - Convert your test case recording into a Coded UI Test - Add assertions to the Coded UI Test- Associate your Coded UI Test to a test case in MTM - Execute your test cases automatically

Having spent most of the last 15 years writing web apps on a Microsoft platform, the switch to iOS was a tricky one for me. I will share all that I have learned in the last year making the transition. You will learn the basics of iOS programming from a .NETters perspective. For any .NET web developers looking to make the jump to iOS, but are not sure what to expect, this session is for you.

Although native applications continue to thrive, more and more focus is being placed on the web as a way to successfully deliver enterprise applications. The primary language of the web is JavaScript and it comes with its own challenges that make it difficult to scale large teams across large projects. The combination of TypeScript and AngularJS changes this by providing a way to design a declarative UI with a clean separation of concerns while providing strong types that make discovery and refactoring easier than ever before. Join principal consultant Jeremy Likness to learn how these two technologies combine to enable large development teams to deliver web-based applications more quickly and efficiently.

In this session, we will give an introduction to development for Windows 8 PCs and tablets that is specifically tailored to Android developers. We will show the Windows 8 approach and Android approach, so Android developers see what is similar and different in the Windows 8 world. We will also provide resources for Android developers, including API mappings and how to get started with simple tasks.

You're a PowerShell convert, and you live with a shell open now. But you're finding yourself wishing that PowerShell handled something differently. You know you could solve the problem with your .NET skills, but how do you tie the two technologies together? Attend this session to learn how to write your own cmdlets and modules, from File > New Project, through dynamic types and testing, through deployment and sharing, and all the way to having your new cmdlets doing work for you. We’ll cover all of that in an hour, so we'll be moving quickly in this mostly-code session. Come learn how to take your PowerShell skills to the next level by leveraging what you already know about .NET development and building a cmdlet to turn your SQL queries into pipeline-friendly objects.

Learn the "black art" of cryptography, including public/private and symmetric encryption, hashing, digital signatures, and a dash of salt. Review the basics of cryptography and what techniques are appropriate for various situations. Discover practical techniques for securing content received on public web sites. Review .NET classes to use for cryptography, how ASP.NET uses cryptography, and how to protect sections of the web.config file.

Single Sign-On – SSO… If you’ve considered single sign-on or identity federation for your organization, those three letters are probably better rearranged – S.O.S. This session will help you sort out all the acronyms and protocols so you can start in the right direction to a successful implementation. We’ll take a look at Windows Identity Foundation and Windows Azure Active Directory (formerly Access Control Service) and how they fit in the overall solution. This session covers: The Basics… -- Token Issuers and Relying Parties (with demo) -- Comparison of WS-Federation, OAuth and SAML-P -- SAML AuthN Token Overview -- Dissection of WS-Federation Web Requests Advanced Topics… -- Identity Federation with Trusted Organizations (with demo) -- Important Architecture Considerations -- Social vs Corporate Identity

The use of non-relational databases is gaining momentum, and can be a great solution in some scenarios. RavenDB is the foremost document database for .NET, and offers support for JSON, LINQ, a REST-ful API, automatic indexing, transactions, horizontal scalability, and many more features. In this talk we'll discuss the pros and cons of non-relational databases, explore the latest features of RavenDB 2.0, and walk through some examples of putting RavenDB to work.

JavaScript dependency loading is tricky business. The scripts have to be loaded in a particular order, they have to add global variables to communicate with each other, and they block they page's DOM while loading. Require.js is an AMD framework that helps take care of many of these issues. It's also easy to use in an MVC application with the proper setup. This session includes an introduction to require.js and how it can be utilized in an ASP.NET MVC application.

What's new in Application Lifecycle Management 2013 Microsoft's application lifecycle management tooling is all about enabling teams to deliver great software. In this demo-packed session, you will learn how to more effectively plan and track work by using the new Web-based project management tools; how to bridge the divide between development and operations by utilizing IntelliTrace in your production environments; and how to help keep team members on-task and ""in the zone"" with the new ""My Work"" and code review features. In addition to making your team more productive, we will show you how you can boost your overall code quality with new features such as code clone and an overhauled unit testing story in Visual Studio 2012.

Let's breeze beyond the tutorials, and see some real life example of how SQLAlchemy can be used in both the ORM and Core modes. We'll take a look at functions, grouping, hybrid properies and their uses in the SQLAlchemy ORM. Then we'll dive into SQLAlchemy Core and learn how to use the SQL expression language to build dynamic queries based on database introspection and simple query building patterns. Finally, we'll dive into how to use Alembic database migrations to deal with your ever changing database needs. We'll also so some example in the Flask world, of how to tie the configuration directly into your application.

For the first time since SQL 7 there is a compelling reason for EVERY SQL Server user to upgrade to the next version and that reason is Windowing Functions. The range of data processing needs that can be very efficiently and cleanly solved with these tools is stunning. Best of all these are NOT limited to Enterprise Edition, like so many other really useful and important features! In this demo-packed session we will cover as many features as we can pack into an hour's time, and you can take the demo code back home with you to review at your leisure!

JavaScript has come into its own as a language for building large, rich applications. Browser improvements have made it lightning-fast and a healthy ecosystem of libraries has risen up around it. Still, building Single-Page applications on your own can be a daunting task. That's where Durandal comes in. It leverages existing libraries like Knockout and RequireJS for data-binding and dependency management, and layers on additional features needed by real-world applications like compositional UI. Come see how Durandal can help you create web applications using state-of-the-art practices and tooling.

In this session Angry Birds uncover concepts of modern JavaScript development. Each bird represents an area of JavaScript along with its strengths. Some topics covered include code organization, events and messaging, MV* frameworks, prototyping and mocking, design patterns, linting, and build systems. The goal is to defeat the pigs and by doing so produce highly tested quality JavaScript code.

More passwords were leaked in 2012 than in all previous years combined, and the technology used to brute-force hashed passwords into clear-text has become trivial to acquire and use. In this environment it is critical that every IT professional know the various methods of brute-force attacks, and industry best-practices for hashing. This talk will review various hashing methods, common mistakes, and the strategies and hardware employed when attempting to brute-force a set of hashed passwords. Included in the talk will be a demo of a computer using a graphics processor to brute-force a hashed password back to plain text.

No really - it's not a nightmare! It's an amazing thing! It will only be a matter of time before Web Workers have wide support - will you be ready to take advantage of the benefits they can offer? In this session we'll cover what web workers *are*, how they can replace certain uses of iframes in your apps today, the advantages of parallelization/processing they can offer and more. Some use cases we may cover include using workers to: 1.) Pre-fetch/transform data in the background 2.) syntax highlighting or spell check 3.) image filtering and manipulation 4.) background polling and/or shared communications 5.) and others!

This session will cover the controls that are new in XAML for Windows Store applications. Those will include new list based controls such as GridView, ListView and FlipView. We will talk about cool new visuals that SemanticZoom allows developer to create. RichEditBox’s great capabilities will be discussed. Other controls that play an important role in creating compelling user interfaces will be discussed as well. At the end we will have a small working application, allowing the user to see and edit the data. Learning objectives 1. Get an overview of new XAML based controls in WinRT 2. Understand the power and capabilities of list based controls 3. Get an idea of how to create compelling user experience with other controls available for WinRT applications.

Twitter Bootstrap is a great CSS framework for building responsive web sites... Orchard CMS is a great framework for managing web site content... This presentation will focus on pairing the two technologies together to build maintainable and responsive web sites.

Amazon and Twitter do it, Wal-Mart & Facebook too….What about you? Big Data Predictive Analytics is pervasive and with HDInsight it's never been more approachable. In this session you become part of the demo as your clickstream data at our fictional e-commerce website drives user and product recommendations using the built-in Mahout (Taste) algorithms. In this action pack session, real-world and practical solutions for moving data into and out of HDFS (with Sqoop), using Mongo or HBase as a source/destination and of course handling Mahout processing in distributive mode will all be covered.

If you’re a C# lover and want to develop mobile applications across iOS, Android, and Windows Phone, then Xamarin deserves your attention. Never heard of Xamarin? Not to worry. They’re the clever folks who brought us Mono for Linux and, more recently, runtime environments for iOS, Android, and Mac. They formed Xamarin roughly two years ago with a laser focus on the mobile space. Xamarin is a really big for C# developers. There are several cross-platform frameworks based upon with web technologies, but this is the first mobile development product aimed squarely at C# developers. Beyond that, Xamarin allows you to build first class user experiences using the same native building blocks available via Objective-C and Java and share common code between platforms. Awesome, right? There’s more. In this session, I’ll get you up to speed with Xamarin and share lessons learned while building apps with Xamarin at Firefly Logic. I’ll give you pointers to resources to use during your learning journey and introduce you to influential members of the community.

You need to handle more data and deliver faster queries, but the options are confusing. In this session, you will learn from battle tested techniques used to speed up SQL Server environments both by scaling up and scaling out. We'll cover which features can save you hundreds of development hours, which features are a struggle to implement, and how you can tell the difference. This workshop is for developers and DBAs who need to plan long term changes to their environment.

The Model-View-ViewModel adaptation of the Presentation Model pattern has proven itself in XAML based technologies. Now it's time to reap the benefit in JavaScript and WinJS. In this session I will show you how to build ViewModels out of your Models, and apply them to Views in WinJS for Windows Store Application development. This session assumes a working knowledge of JavaScript, HTML, and at least introductory WinJS experience.

You’ve most likely heard the term Hypermedia, and you might even know what it is. Does it work in the real world, or is it just another buzz word? Have you used it? Should you use it? What advantages does it give you in building both server and client applications? In this presentation I hope to start a discussion around these very questions, and try to show some practical examples of how to use Hypermedia in a server-side API, and how to consume Hypermedia in a client (in my case, JavaScript) application.

Be afraid. Be very afraid. For you are about to enter the mysterious and foreboding land of regular expressions. A land of strange-looking hieroglyphics. A land of many flavors and implementations. A land whose inhabitants possess seemingly magical powers over text. But fear no more, for you needn't make the journey alone: a guide and a map await you. In this session, we'll take a whirlwind tour of the features found in most regular expression implementations. Then we'll dive deep. We'll take a peek inside a regular expression engine. From character literals to character classes, from backreferences to look-around, you'll see every step a regular expression engine takes when it parses text. By the end of the session, you'll be able to think like a regular expression engine.

We are going to examine a variety of oopsies MANY developers fall prey too - some obvious, some pretty subtle and some down right sneaky! Lots of code examples with the bad AND good code presented. I GUARANTEE that you will find things here that will either prevent you from getting bad data, throwing unwanted errors or vastly improving your database application's performance. I have given this talk over fifty times now and it is always very highly rated!

You've gone and built the most amazing new web application, it's going to make you hundreds of cents. For all the Web APIs and SPAs that make it tick there's one thing that's not been considered. Airplane mode. Invariably someone is going to be using your site and loose connectivity, but how will your application handle that? What happens when they try and create data? In this session we'll be looking at the various options available when it comes to handling data in an offline web application and how you can leverage them as you transition between online and offline within your web application.

Writing web services using the ASP.NET Web API can be quite satisfying. For SOAP developers accustomed to strict separations between bindings and contracts, it can also be a frustrating experience. Without proper foresight and planning, the boundaries between controller actions and the transport can get fuzzy, potentially leading to design complications as your application matures. In this code-focused session, you'll learn about one of the Web API's key extensibility mechanisms that can help to separate an application's "plumbing" from its business logic and data-handling concerns. When you've completed this session, you'll understand the Web API's object model and how to write global and per-route HTTP handlers to solve a range of cross-cutting problems.

If you have not been paying attention Javascript has pretty much won the war of 'write once, run anywhere' as it can now run on both the client and server side. And if your like most people who are new to JavaScript, it can seem scary and intimidating to try to pick up. This is where Typescript comes in. TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. Typescript tries to make sense of some of JavaScript's language 'issues' (aka wth does that syntax mean). In this session we will focus on how to go from 0 to 60 in JavaScript in no time flat all because of the awesomeness that is Typescript. By the end of this interactive session you should be hooked on JavaScript , I mean Typescript, and the fear and intimidation of learning JavaScript should be gone.

You don't need to be an expert to create an iOS app from a RSS feed. Our journey will begin by creating a RSS parser class and NSLogging output to test it out. Once that milestone is complete, we will then use that class to create an iPhone app to display the top 100 movies from Netflix. Work along and/or use github for the code later. We will use a storyboard and the Master-Detail template to build the app. If time permits, we can explore building the same app with xib files.

I have worked with and studied several top developers (e.g., leaders of an open source project with millions of downloads) as they write code. Both anecdotal and video evidence shows that these developers are fixing bugs 10-15X faster than others. Yet when analyzing these developers' performances it's not their superior brainpower that sets them apart, it's their workflow strategy. Instead of wasting time clicking around the Solution Explorer for a starting point they search for relevant files and get started instantly. Instead of haphazardly scrolling through open files they navigate the code by following its structure (e.g., references and calls), eliminating many costly distractions. Adopting this search-driven, structured workflow allows even more modest developers (like myself) to dramatically increase their productivity. In this talk I'll focus on two things: providing evidence of the problem and offering practical advice on how to implement this approach in your own Visual Studio. To understand the problem we'll analyze videos of developers working on real bug tasks, listen to interviews with top developers, and even delve (briefly) into a few academic studies. To help implement this approach in your own workspace we'll download the appropriate tool support (e.g., the free, open source Sando extension), work through an example bug together on my machine, and finally I'll provide an example for you to try on your own laptop. By the end of this session you should be able to search and navigate code, and ultimately squash bugs, much more efficiently.

The Windows Runtime is the runtime that drives Windows 8 and the new Windows Store apps. The runtime enables developers to build rich client apps that run natively on Window 8 devices. In this session, Jeremy Likness explores the various built-in components and APIs that enable Windows Store apps to connect to SOAP, REST, and OData endpoints and syndicate RSS and Atom feeds. Learn how these tools make it easy to build Windows Store apps that are alive and connected to the internet.

HTML5 includes a Canvas element that allows for dynamic, scriptable rendering of 2D shapes and bitmap images. Using this, web developers can draw images directly in their web pages with JavaScript, enabling applications such as games, mapping, and data visualization to offload the rendering to the client. One problem with the Canvas, though, is that the rendered image is just that: an image. The user is unable to interact with any of the shapes that are drawn to the Canvas. However, an open source library called Kinetic bridges that gap, allowing shapes or images to be drawn using the existing Canvas API, event listeners attached to them, and manipulated individually using mouse or touch (i.e., move, scale, and rotate). This session will introduce how to use the Canvas API and Kinetic.js in a desktop or mobile web application.

For many web developers, it was jQuery that really pushed them from tinkering to full blown web developer. In fact, many developers slip and call themselves a "jQuery" developer instead of a "JavaScript" developer. Did you know that there are a lot of really great JavaScript libraries that don't rely on jQuery at all? Blasphemy, you say, but it's true. In this presentation, we'll take a look at several popular JavaScript frameworks and plugins that take your applications to the next level, but don't have a need of jQuery.

In this session, attendees will explore the limits and opportunities of what software developers can influence and change in process of releasing software. It is common, on many teams, to become frustrated and sometimes despair when schedule and resource constraints prompt managers to make ever increasing demands on software developers than sometimes contradict what professionals know is the right path to quality software. Martin Fowler calls this conundrum the "Tradable Quality Hypothesis." We will explore the options teams and individual developers have to cope with and in some cases push back against these constraints.

Test Driven Development is widely recognized as a proven method to improve both the quality and maintainability of code. But a new breed of application, the Single Page Application, has become popular, and the need to test client-side JavaScript (never a commonly tested language) is ever more urgent. Many frameworks have arisen to address this need. Commonly referred to as JavaScript MVC frameworks, they allow us to build ever larger applications in the browser. Angular JS is unique among these frameworks because it was built from the ground up to support automated testing. This talk will cover how to do test driven development with Angular JS.

ASP.NET MVC has come a long way from its initial release in 2009. Its feature set and maturity have grown by leaps and bounds with each release, and the new fourth version is no exception. In this presentation, we'll cover some of the new features, including the ASP.NET Web API, display modes, mobile enhancements, bundling and minification, and asynchronous controllers. You'll come away with an understanding of what the new framework version offers, and why you might want to upgrade your existing MVC apps to the latest and greatest.

Breaking free from the confines of the cubicle farm and going out on your own can be one of the most satisfying things you do for your career. It can also be one of the most terrifying. This session will answer the most common questions I've been asked over the years such as "How do I get started?", "Where do I find clients?", "How much do I charge?" and many others. Come find out if the grass really is greener on the other side.

Knockout is a Javascript library that helps you use the MVVM pattern in writing web apps. It provides 2-way data binding between properties in your code and objects in the DOM, decreasing the clutter in your code and saving you from the tedium of manually setting data on and retrieving data from the DOM That's great, but will it really work for the crazy things that you need for your web app? How far can you go with Knockout? How much can it's data bindings really do? Will it work with jQuery UI widgets? Come to this session if you want to learn how to extend Knockout with custom Bindings and custom Extenders. We'll start with a brief overview of how to use Knockout, and we'll review the standard Knockout Binders. Then we'll dig into the Knockout source and see what a binder is made of, and we'll create one ourselves. We'll also look at how to create a custom Knockout Extender, and how to know whether you need to create a Binder or an Extender. And we'll wrap up by showing how to create a custom Knockout Binder for jQuery UI widgets.

Successfully working remotely is a skill that can be learned. This session will cover a variety of skills that you'll need to be effective and provide value when working remotely.

Adopting Scrum is a complete paradigm shift for many teams. It is usually hard to break old habits and form new ones. Even though Scrum is an fairly lightweight methodology, development teams that are adopting Scrum for the first time always struggle. In this session we will learn how to make the Visual Studio ALM tools an ally for team that are implementing Scrum or other agile methodologies.

As the need for security increases, the use of biometrics will become more and more prevalent. This session will discuss topics in the space of Biometrics and introduce you to a few devices that are emerging in the field, such as palm vein scanners, touch-less fingerprint readers, and Kinect.

JavaScript's lack of a language-level module system does *not* have to be a handicap when it comes to good code organization, scope control and dependency management. Come see how following the Asynchronous Module Definition spec and using a module loader library like require.js can revolutionize how you not only structure your code, but relieve the pressure of dependency management while gently guiding you with good architectural opinions for which you'll be thanking yourself for years to come. We'll cover the basics, but we'll also dive into the build utility (r.js) to look deeper at how you can work require.js into your development and build tool chain.

What do you do right now to automate your environment? More than likely it is scripts. Those scripts can be difficult to maintain, as well as difficult to share. Come learn how System Center Orchestrator makes automation in your environment easy, yet powerful. From the built in activities, to building custom ones, you will leave this session with real world examples and best practices for automation in your environment.

If you’ve ever been involved in promoting cultural changes within an organization, you may have experienced something even more disheartening than flat-out rejection: a full rollback of cultural change and a decade-long resentment of anyone remotely associated with the implementation. This has happened at countless organizations with agile, with SOA, with virtualization – and it’s starting to happen with DevOps. How can such as simple idea that’s been so successful at so many companies become such a resounding failure at others? It’s not the organization, and it’s certainly not DevOps. The problem lies in the implementation, and ultimately, with its promoters and champions. In this talk, I’ll discuss both technical and organizational strategies for a successful long-term DevOps implementation, go over a few big failures at big companies, and cover the common and not-so-common pitfalls when promoting this type of cultural change.

This session will concentrate on features of SSDT as it pertains to creating and updating data structure while incorporating your databases into source control management as well as full application lifecycle management. Discussion will include structure management, seeded data management and deployment. Build integration features will also be part of the talk. Learning objectives 1. Core features of SSDT 2. Source control and artifacts creation 3. Refactoring and build integration

Since the launch of Kickstarter, many projects have raised millions of dollars in funding. Beneath these headlines though lives a vibrant community of smaller projects getting the funds they need every day. Kickstarter’s all-or-nothing approach has unlocked a source of crowdfunding that anyone can use. With over a 40% success rate, the question isn’t “can” I raise money on Kickstarter, but “how.” This session is an in depth look at what makes a project successful and what to avoid, including an in depth look at project statistics, pledge level tatics, and do's and don'ts for your pitch video. We'll also discuss what type of projects are a good fit for crowd funding and how to raise awareness for for project once launched.

Triggers are extremely powerful and useful (if somewhat rarely needed) objects that are coded very similar to a common stored procedure. Yet for their similarity, there are some very important differences that need to be understood. In this session, I will walk through what goes into writing a robust DML trigger, starting with a simple version of a trigger, and working through some very useful applications of DML Triggers.

With Backbone, don’t leave your jQuery plugins shivering out in the cold production air. We can keep them warm and toasty in a coat of Backbone view goodness. Gone are the days when we just copy and paste plugin files and start hacking in our script tags. Now that we have the expressiveness and modularity of Backbone views to manage our application behavior we can build a reusable facade for jQuery plugins.. I’m going to provide a guide to wrapping our jQuery plugins cozily in Backbone views. I’ll be giving you an alternative to large spaghetti .render() methods that make every jQuery plugin initialization call. I’ll walk you through the key tactics in decomposing a plugin into it’s core functionality and explain how to flexibly build your backbone view. We will also discuss the best patterns and styles for wrapping different kinds of jQuery plugins. Most notably, I’ll be going through the process of wrapping jCarousel in a Backbone view that can be reused in many different situations.

Push Notifications are nothing new, in fact we have been doing them for quite some time even before Apple released the Apple Push Notification System in 2009. So when Microsoft released the Windows Phone OS and made Push a first class citizen why did it change the way we looked at mobile? it changed because in transformed the very concept of what we did. Microsoft immediately began talking about this as the app vs experience debate. Since then all platforms have begun embracing Push as central to the betterment of users. Microsoft took this to the next level with Windows Azure Mobile Services which allows developers to, through a central interface, send push notifications to all major platforms (Apple, Android, WP, Win8). This talk will focus on some of the history of Push but centrally will show how a cross platform push system can be designed using the Azure Mobile Services. We will discuss how push notifications are central to creating the concept of "experience" vs the traditional "app".