PRECON01: 50 Things All SQL Server Developers Need To Know! (Saturday, April 12)

Kevin Kline
Aaron Bertrand
Level = 100-300

No matter your level of database experience, there are always new things to learn (and even un-learn). In this workshop, we will cover various aspects of SQL Server, giving you insight into how to design and develop for performance, maintainability and scalability. Among a host of other things, we'll talk about how to identify indexing opportunities, avoid a variety of pitfalls with date handling and date range queries, prevent triggers from becoming a performance bottleneck, eliminate cursors (or at least optimize them when you do need them), and best handle dynamic SQL and optional parameters. Come draw on our 30+ years of collective experience and learn about patterns to embrace and anti-patterns to avoid, with all the ''why?'' and ''why not?'' you could ask for. With live demos, practical examples, and real-world stories, you can take many of the techniques you learn throughout the day and implement them the minute you get back to work.

PRECON12: AngularJS SPA Development - 0 to 60 (Sunday, April 13) Hands-on Bring your own Laptop

John Papa
Dan Wahlin
HTML5 Single Page Apps (SPAs) focus on delivering enhanced user experiences with significant client-side interactions using JavaScript, HTML5 and CSS. AngularJS does all of the heavy lifting for you to pave the road towards building a SPA. This workshop explores the core pieces that help you build end-to-end SPA solutions using AngularJS including code structure and modularity, using data binding and MV*, abstracted remote data calls, page navigation and routing, rich data features, and responsive design.

Throughout the workshop you'll learn how to build robust SPA applications with Angular. You'll see several focused demos and full featured apps that will help you learn and understand the role of key AngularJS components such as modules, controllers, factories, directives, and more. We'll wrap up with a dive into rich data management using Breeze.

This workshop covers:
- SPA fundamentals
- Importance of Separation of Concerns (SoC)
- JavaScript patterns for creating organized code
- Key components of AngularJS
- How directives can be used
- The role of views, controllers, and $scope
- Managing remote data calls using services or factories
- The role of modules and how they can be used
- Routing and page navigation
- Handling dirty data
- Data validation
- Data binding
- Using rich data with Breeze.js
- Navigating and App LifeCycle
- Debugging Tips

PRECON08: Architecting Applications for Multiple UIs (Sunday, April 13)

Paul D. Sheriff
The techniques for building applications have changed dramatically in the last few years. Gone are the days of single-tier, battle-ship gray, boring user interfaces. Users demand that your applications (or portions) run on more than one device. This one-day workshop will take you on a tour of how you should be architecting your application by breaking it up into services. You will learn how to create your business rules and data layer as a service. This workshop will assume you have some knowledge of .NET but have been developing applications the old way and you are now looking to see how to use WCF and the Model-View-ViewModel (MVVM) design pattern to create applications that can be run on more than one user interface platform. In this one-day workshop, you will learn to build a set of services that can be re-used in WPF, Silverlight, Windows Phone and ASP.NET. The focus of the day is creating easy-to-use, easy-to-maintain and simple services that can be used and reused in many applications. At the end of the day, you will walk away with the skills you need to bring your old applications forward into a service-oriented architecture.

The following topics will be presented in this one-day journey where we assume you know nothing about WCF or developing service-oriented applications. Along the way, you will become very comfortable with the techniques you will need to know to create services that can be used in a variety of user interfaces.

-From zero to a service-oriented architecture (SOA)
-Simplify the MVVM design pattern
-Create your own data layer, entity classes and validation system
-Create a typical n-tier application using WPF, Silverlight, Windows Phone and ASP.NET
-Tips to spice up your application's user interface

PRECON10: Deep Dive into SharePoint App Development (Sunday, April 13)

Paul Schaeflein
Rob Windsor
The SharePoint App Model has been out for a year now and there's no shortage of material on how to get started using it. What's in short supply is material that goes beyond the basics and discusses what you may face when building production-level Apps. That's where this workshop comes in - it covers, in depth, the parts of SharePoint App development that go beyond the basics. We'll start with a demo-heavy look at the Client Object Model (CSOM) and REST API and how they have evolved and expanded since SharePoint 2010. The coverage of these APIs will be done along with an examination of the use of SharePoint-Hosted Apps. We will then move to a look at building Cloud-Hosted Apps and how to handle the added complexity inherent to them, specifically authentication, deployment and hosting.

PRECON03: Developer's Guide to SQL Server Operations (Sunday, April 13)

Jeremiah Peschka
Kendra Little
Level = 200

You're a developer who has to administer SQL Servers, but you've never had formal training. You're not entirely sure what's going on inside this black box, and you need a fast education on how SQL Server works. In one day, you'll learn how to make your SQL Server faster and more reliable. You'll leave armed with free scripts to help you find health problems and bottlenecks, the knowledge to avoid common pitfalls, and a plan to get SQL Server under control.

* How to tackle an unknown, out of control environment
* Understand how far backups will (and won't) take you
* Maintenance anti-patterns: avoid common mistakes
* Choose the right maintenance tools
* Monitor with built-in tools
* Find SQL Server's bottlenecks with the DMVs
* Identify your heaviest hitting queries
* Collect the right performance metrics
* Learn how to tell if tempdb is a problem

Categories: Database Administration, Diagnosing Problems, Configuration, Maintenance

PRECON11: Federating SharePoint Online with Your On-premise SharePoint Environment (Sunday, April 13)

Eric Harlan
SharePoint Online can be a bit of a black box. In the past releases of SharePoint on-prem, we've been made used to the premise that we expect new features in SharePoint. With SharePoint Online we have to then ask what features do we not have access to that we're used to. In this workshop, we will talk through some of the gotchas like Migration and Federation. We'll also walk through these demos to show you exactly what to expect when it comes to roll out your Hybrid Cloud environment.

PRECON13: On the Metal: Essential HTML 5, CSS 3 and JavaScript for All Developers (HANDS-ON, BRING YOUR OWN LAPTOP) (Sunday, April 13)

Todd Anglin
HTML5 and CSS3 have arrived and they are redefining rich, standards-based web development. Features previously the exclusive domain of browser plug-ins can now be added to web applications as easily as images. Understanding the new power that these standards define, as well as the rapidly increasing power and speed of JavaScript in modern browsers and devices is essential. In this full-day workshop, you will be guided through the new features in HTML5 and CSS3, with special attention to how these technologies can be used today in new and old browsers. Among the topics that will be covered:

-HTML5 fundamentals and elements
-HTML5 adoption strategies
-HTML5 forms and validation, geolocation, offline applications, localstorage
-HTML5 ''Polyfills''
-CSS3 fundamentals & browser support
-CSS3 styles (shadows, rounded corners, gradients) and animations
-HTML5 and CSS3 browser support, tips, and tricks.
-JavaScript best practices for modern browsers
-Modern HTML application architecture (SPA)

Leave this workshop with the knowledge you need to start using HTML5, CSS3, and JavaScript to build modern standards-based applications for the web and mobile devices. LAPTOPS ARE ENCOURAGED, but not required.

PRECON04: Practical Disaster Recovery Techniques (Sunday, April 13)

Paul S. Randal
Level = 200-400

Disasters happen plain and simple. When disaster strikes a database you're responsible for, can you recover within the down-time and/or data-loss limits your company requires? What if your plan doesn't work? This workshop isn't about how to achieve high-availability, it's about how to prevent or overcome the obstacles you're likely to hit when trying to recover from a disaster - such as not having the right backups, not having valid backups, or not having any backups! In this demo-heavy workshop, you'll learn a ton of practical tips, tricks, and techniques learned from 15 years of experience helping customers plan for and recover from disasters, including less frequently seen problems and more advanced techniques. All attendees will also receive a set of lab scenarios for further study and practice after the class with assistance from Paul.

Topics covered will include:
* Backup and restore strategies and internals
* Physical database architecture for faster recovery
* Dealing with missing or corrupt transaction logs
* Dealing with restore problems
* Dealing with data corruption with and without backups
* Using EMERGENCY mode
* Manual repairs of system tables and using DBCC WRITEPAGE

Categories: Backup, Restore, Transaction Log, Corruption, Recovery

PRECON05: Queries Gone Wild: Real-world Solutions (Sunday, April 13)

Kimberly L. Tripp

Level = 200-400

Have you ever wondered why SQL Server did what it did to process your query? Have you wondered if it could have done better? And, if so, how? Transact-SQL was designed to be a declarative language that details what data you need, but without any information about how SQL Server should go about getting it. Join order, predicate analysis how does SQL Server decide the order or when to evaluate a predicate? Most of the time SQL Server gets the data quickly but sometimes what SQL Server does just doesn't seem to make sense. Inevitably you'll encounter certain workloads and queries that just aren't performing as well as you expect. There are numerous reasons why query performance can suffer and in this full-day workshop Kimberly will cover a number of critical areas while showing you how to analyze a variety of query plans throughout the day.

But, it's not just about analysis - it's really about solving your query performance problems. Each problem has a different way of handling it and you'll walk away with a plethora of strategies to troubleshoot and tackle even the most gnarly of query plans. When data distribution is heavily skewed, cardinality estimation (how many rows the Query Optimizer expects each operator to process) can be wildly incorrect resulting in poor quality query plans and degraded performance. You've probably seen the advice to just rebuild indexes or update all statistics if a query plan looks wrong - but is that the right advice? In many cases, NO! These are ''sledgehammer'' approaches that only solve the immediate problem. In this full-day workshop, you'll learn much more finessed ways to solve query plan quality problems.

Topics covered include creating, using, and updating statistics (including filtered stats), using forced parameterization and templatized plan guides, plus stored procedures and how they can leverage filtered statistics. Most importantly, the solutions you learn do not have to stay in Orlando, they can be taken back and applied immediately.

Topics covered (agenda):

Query Optimization
- Understanding Cardinality and Selectivity
- How SQL Server ''predicts'' data sets

- When are they created vs. when are they updated
- Full-scan updates vs. sampling

- If statistics aren't available, what happens?

Data distribution
- Evenly distributed data (yeah, right)
- Problems with uneven distribution
- Analyzing Data Skew
- Filtered Statistics (FS)
- Automating the creations of FS

Plan Caching
- Statement Execution

Simple parameterization vs. forced parameterization Stored Procedures
- Creation/Optimization
- Recompilation
- Coding practices

Categories: Statistics, Execution Plans, Performance, Cardinality Estimation

PRECON06: Service Orientation Technologies: Designing, Developing and Implementing WCF and the Web API (Sunday, April 13)

Miguel Castro
Service Oriented Architectures are the best way to ensure that today's applications are extensible, maintainable, and scalable in a volatile world filled with ever-changing demands. Decomposing your systems into smaller, loosely coupled, and more autonomous components ensures that your application can continue to grow or change without having to continuously undergo rewrites or redesigns. But with great power comes great responsibility (don't say it), and the need for great technology and tooling. WCF is the heart of Microsoft's stack for building connected systems and loosely coupled components. ASP.NET Web API is the latest addition to this stack in a world where REST and it's interoperability power becomes more necessary and in more demand. Come learn both of these technologies and how to properly use them, apart and together. I'll teach you what a Service Oriented Architecture is and how to use WCF and Web API from the ground up. Then I'll show how to integrate both these technologies together into applications whose clients may vary from WPF to ASP.NET MVC to Windows 8 Tablet apps. I'll cover setup and consumption of your services end-to-end, showing you how and where to properly set up your projects, properly use proxies, contracts, and even REST URL design. You'll have the knowledge of how to use service technology and to properly implement it in a clean and elegant fashion.

PRECON07: The Architecture Clinic (Sunday, April 13)

Juval Lowy
Wonder about architecture best practices, guidelines and pitfalls? You sense there is more to decomposing a system based merely on requirements? Wonder how to design world-class systems? You understand the concepts but not how to apply them? In the first half of this high pace tutorial, Juval will explain his original approach to large system analysis design and his method. Then, he will present a comprehensive case study, outlining the architecture that addresses the requirements, discussing logical tiers, security, interoperability, scalability, transactions, and other aspects of a modern application. You will see how to approach rarely discussed topics such as allocation of services to assemblies, allocation of services to processes, transaction boundaries, identity management, authorization and authentication boundaries and more. Time permitting you will also see how to design the project behind that system.

PRECON09: The C Word: Modern ALM for Modern Teams (Sunday, April 13)

Brian Randell
Modern applications that have multiple UIs-desktop, tablet, phone, and more-require a team that's humming along hitting it at all levels. Today it takes more than cutting code to ship something that your users truly love. The mantra for the modern team is ''Continuous, Continuous, Continuous.''

In this workshop, Brian will guide you down the path to shipping solutions your users truly love. He'll do this by helping you understand continuous value delivery. You'll learn about all the big ''Cs'' for modern development: continuous feedback, continuous integration, continuous testing, and continuous deployment. You'll learn about all these in the abstract and how they apply to all teams no matter what tools you use.

Then, Brian will show you how to apply these processes to your team using Visual Studio and Team Foundation Server/Team Foundation Service. Brian will cover the most recent released version as well as cover what's new in the forthcoming update, Visual Studio 2013. So come spend and spend a day with Brian. Get your questions answered and learn how you can build high quality solutions in a timely fashion that your users truly love.

PRECON02: What's New in SQL Server 2014 (Saturday, April 12)

Bob Beauchemin
Level = 100-400
SQL Server 2014 is just around the corner, and this 1-day session goes into detail about the most important and compelling new features.

* Memory-optimized tables and compiled stored procedures (aka Hekaton)
* Clustered columnstore indexes and other columnstore enhancements
* New cardinality estimating for query plans

Hekaton: SQL Server 2014 introduces a new in-memory storage engine for greater speed in processing. In addition, rather than reproduce the page-based structures of the original storage engine, this engine operates on linked lists of hash buckets - all structures are lock and latch-free. Multi-version storage and optimistic concurrency are used to get the most out of the new engine. A new kind of T-SQL stored procedure can be compiled into assembly code that uses table-specific I/O routines to bump up the speed increase even more. The most interesting and useful implementation detail is that this is all integrated with native SQL Server - no new DDL and DML to learn, and integration between memory-optimized and ''traditional'' tables is built-in.

Columnstore Enhancements: Columnstore indexes and batch processing mode were introduced with in SQL Server 2012. But the columnstore index in 2012 was read-only and required an additional copy of the ''base'' data, and a limited set of query iterators supported batch mode. In SQL Server 2014 native, updatable, column-based storage (known as ''clustered columnstore indexes'') mean you don't need extra copies of your data to use the in-memory, column-based, xVelocity engine. In addition, percentage of query processor operations that can use batch mode (a batched improvement over row-by-row processing) has increased dramatically.

Cardinality Estimation Enhancements: Having accurate row estimates is crucial to obtain the best query plans. In SQL Server 2014, the cardinality estimating calculators have been vastly overhauled based on a decade or more of real-world experience with the most difficult query patterns. Among the patterns that give improved estimates are even-increasing keys and columns with correlation. One of the most interesting features is the instrumentation of the cardinality calculators through extended events you can see how the estimate is produced.

Come join us for a whole day of these features in depth.

Note: although these three changes alone are mentioned, there are more changes coming in CTP2 and beyond. Based on public availability of the information, I'll discuss and demonstrate these as well.

POSTCON08: Building Data-Centric Single Page Applications with Durandal, Knockout, Breeze and Web API (Thursday, April 17)

Brian Noyes
You need to build an HTML client app for the browser or to package as a mobile app and there is a lot of data presentation and manipulation involved. You may be fully embracing the Single Page Application (SPA) architecture, or you may just have some highly interactive and data-centric pages you need to implement. You want to make sure you end up with good, clean, maintainable, testable, and easy to implement client and server side code. This workshop will take you end-to-end, showing you how to put together a rich data driven HTML client interface using Knockout and Durandal to put together a decoupled data bound UI using MV* separation patterns and dependency injection. You'll also get in depth exposure to using Breeze to do the heavy lifting on making the service calls for you, tracking changes on the entities, sending changes to the server side in batches, and more. Then you'll also see how to set up the server side using Web API to expose the services consumed by your client. By the end of the day, you will know how to build out the vertical slices of your app from top to bottom.

POSTCON04: Code Generation with Roslyn (Thursday, April 17)

Kathleen Dollard
Code generation is the process of creating (and recreating) sections of your code. It can speed development, consistently express your architecture, improve quality and reduce maintenance costs. But, if generating a million lines of code in a minute solved problems, why aren't we already doing it? You need techniques to interweave unique details of your application, your chosen architecture, and semi-redundant details of code. Template tools that include T4, Razor and Roslyn let you express semi-redundant code along with special refactorings to improve code reuse and isolate unique changeable sections of code. Code generation also relies on metadata - a pattern of explaining what your building - often the definition of the domain. You'll see the benefits and limitations of Code First, database extraction, and other approaches. Tying code generation together lets you create anything from tricky classes to the framework for a full application. In this workshop, you'll also see code generation use in support efforts, including tracing and unit testing. Recent improvements mean the time is ripe to introduce code generation into your development effort, but code generation is not a silver bullet. Boring, stupid aspects of your development effort will drop at least an order of magnitude, but if you are blind-sided by other aspects of generation, your efforts can descend into complexity. Spend a day with code generation expert Kathleen Dollard to learn how to reap the rewards of code generation without falling into its traps.

POSTCON06: Dan Holme's SharePoint MasterClass: Governance (Thursday, April 17)

Dan Holme
Join Dan Holme, global governance thought leader, for a full-day workshop on end-to-end SharePoint governance. Dan Holme is a SharePoint MVP, author of the official Microsoft SharePoint 2010 Training Kit, and one of the most respected SharePoint experts in the industry. He brings to the workshop experience with thousands of organizations worldwide, in every vertical, and every size: from small businesses to most of the Fortune 100 and many of the Global 1000. This workshop has been delivered in sold-out venues on five continents.

Through in-depth discussion of business and service governance, Dan integrates elements of respected management, project and development frameworks, informed by his experience with and lessons learned from enterprises around the world. Dan identifies the critical factors for successful governance, including vision, roles and responsibilities, accountability, measurability, process, and iteration. You come away with messages you can use to understand and communicate the role of SharePoint to your organization, an invaluable framework with which to translate business requirements to SharePoint architecture, tips for avoiding requirement gathering spin-cycles, and an understanding of the strategic, cultural, technical and procedural components of a successful SharePoint implementation.

Dan will present a one-of-a-kind look at what it takes to architect a governable SharePoint implementation that delivers "big wins" for your business and scales effectively and manageably-in both size and functionality-to support rapid adoption of this powerful platform. While every SharePoint environment is different and serves diverse business needs, Dan will identify the common obstacles, issues and hot topics he has seen in 18 years of experience advising some of the largest enterprises in the world.

POSTCON03: Experimental Design for User Interfaces (Thursday, April 17)

Billy Hollis
Here's your opportunity to try your hand at designing compelling user experiences for the latest technology stacks. First, you'll get a short introduction to some of the most important design principles, with examples of those principles in use and being violated. Then you'll get a chance to tackle a real design challenge as part of a small team. This extended exercise starts by demonstration of a business application that needs to be replaced, and a guided round of user observation and questioning. Each team will then analyze where the old application falls short and where it can be improved, based on the design principles it violates and the information gleaned from the user. Your team will try its hand at designing multiple, experimental alternatives that leverage more modern UI, using storyboard sketches and other design options. Those first efforts will be evaluated by the instructor and the entire group, and you'll get a shot at another round of design generation. Finally, a winning design will be selected, and the winning team will receive prizes. Come prepared to learn some real design concepts and processes that you can take home and use immediately.

POSTCON09: Hacking the Creative Brain (Thursday, April 17)

Denise R. Jacobs
As tech professionals, what we need is a way to work better so that we can create more, right? Our brain is our most powerful tool, but so often the practices and culture of work only stifle our efforts to produce fresh ideas and approaches when most needed. As developers, we hack all of the time. In order to have more creative productivity, we need to do is reapproach and modify how we use our brains on a daily basis in order to access more of its inherent processing power.

Through exploring various concepts and approaches, including the neuroscience of creativity, productivity techniques, and emerging practices that spur innovation, we'll discover not only the ways in which our brains work best, but also what's behind the times when we feel on fire with creativity and when we don't. We'll translate this information into processes and techniques for dramatically enhanced creative productivity. Beware: this workshop challenges the standard norms around concentration, focus, productivity, and may change how you work for the better.

POSTCON07: Introduction to Client-side Development in SharePoint (Thursday, April 17)

Mark Rackley
With the creation of SharePoint 2013's new SharePoint Hosted Apps and the continued momentum of companies moving to the cloud, client-side development has quickly evolved from a once shunned technology into an essential skillset that all developers (especially SharePoint developers) need to learn. In this workshop, attendees will learn essential skills that they can begin to use immediately. Including:

1. The pros and cons of client-side development and how to get started
2. How to use third-party libraries like jQuery and jQuery plugins to bring your applications to the next level
3. How to use the Client-side Object Model to interact with SharePoint list data

POSTCON01: Make SQL Server Apps Go Faster (Thursday, April 17)

Jeremiah Peschka
Kendra Little
Brent Ozar

Level = 200

You're a developer or DBA stuck with a database server that's not going fast enough. You've got a hunch that the biggest bottleneck is inside the database server somewhere, but where? In just one day, you'll learn how to use powerful scripts to identify which queries are killing your server, what parts of the database server are holding you back, how to tackle indexing improvements, and how to identify query anti-patterns.

* How wait stats tell you where to focus your tuning
* How the plan cache shows you which queries are the worst
* How to make fast improvements by picking the right indexes
* When to use filtered indexes and indexed views
* How to identify and fix the most common query anti-patterns

Categories: Performance Tuning, Index Tuning, TSQL Tuning, Diagnosing Problems

POSTCON02: Windows Azure SQL Database from A to Z (Thursday, April 17)

Bob Beauchemin
Level = 200-400

This day-long session covers Windows Azure SQL Database architecture, management, development, and database deployment. Azure-specific topics such as connection and command throttling, federations, service releases, and functional limits on T-SQL DDL and DML are discussed in detail. I also cover the latest functionality such as DAC-based development and related offerings such as Data Sync and import/export. Because the Windows Azure SQL Database offerings are improved and expanded every three months or so, I'll cover improvements which may not exist at the time of this writing.

Most importantly, this is a technical presentation and not a marketing presentation. We'll look at everything you need to know to be successful on Windows Azure SQL Database - from A to Z!

Topics include:
* Administrative portal and REST-based APIs
* Your master database 
* Logins and roles
* DMVs and management strategies
* T-SQL best practices for cloud development
* Supported DDL and DML
* Programming quotas and throttling
* Connection and retry strategies
* Federations
* SQL Azure Migration Wizard
* Import-Export using SSIS, BCP, and the portal
* Data Sync