Your code is right. Other people are just using it wrong!

Learn 4 simple techniques to prevent people from using your code incorrectly. We'll apply those techniques to a class in the .NET Framework that is really easy to get wrong. By the time we're done, you'll have to try really hard to mess it up.

Some APIs will throw exceptions when you get something wrong. That's not helpful! I'll show you how to write an API that guides you toward correct code. It won't even compile unless you get it right.

These 4 techniques are built into the C# language today, so take advantage of them! Everybody on your team will thank you. And you'll spend less time fixing their bugs.

Stuck in Java and looking to get a lot more productive? Come join us today for a talk from Igor Polevoy on how to make your Java life easier - he will present ActiveJDBC, the implementation of Active Record in Java, and ActiveWeb, a full stack web application framework in Java, both inspired by Ruby on Rails. Learn how to increase productivity in Java as well as improve code quality with true TDD/BDD.

The .NET Framework doesn't lack support for asynchronous programming. There are several ways to accomplish it. What we don't have yet is a way that doesn't obscures the intent of the code.

Consider the following question: What is more important, what the code is trying to do or the fact that it was written asynchronously? If your answer was the former, you'll probably like what you'll find in the Async CTP for Visual Studio.

Come to this presentation to see the new language features added to C# (and Visual Basic) that pretty much take asynchronism out of your way while still embracing it. Find out how a couple new keywords can make your code asynchronous and help you eliminate blocking calls without spawning new threads.

This story starts out literally like a movie - millions of dollars on the line and the clock is ticking. We had a large dataset we needed to run expensive calculations on and our existing tools couldn't cut it. Clojure came to our rescue with its wonderful combination of simplicity and performance. But that's just the beginning. I'll also tell the tale of how our little Clojure script grew up. I'll talk about how we constructed our test suite, our experience refactoring Clojure, and the delicate art of introducing new developers to their first Lisp.

Here’s a talk that explains how the use of Microsoft Robotics Developer Studio (RDS) with microcontrollers enables greater control and flexibility. We’ll build a project to build a service which will allow RDS to talk with a Netduino. Visual Programming Language in RDS it makes it easy to consume these services for advanced projects.

RubyMotion is a tool that lets Ruby developers write native iOS apps using the Ruby language. It's based on MacRuby which is an implementation of the Ruby language for Mac OS X. This talk will introduce RubyMotion with some simple live code demos and a twist of TDD. The level is introductory; you don't need to know Ruby or iOS to attend.

In this talk we will introduce the REST architectural style and look at what goes into designing a good REST API and what you should expect when consuming a REST API. We will also look at the new ASP.NET Web API stack that is part of ASP.NET MVC 4 and how it can be used to create REST API's.

If you are a professional developer or a hobbyist, you may find yourself doing more design work than you ever expected. This was not a problem, until you were told there were rules you had to follow for good design.

During this session, I will dive into a few basic topics such as the four basic design principles that create the CRAP acronym, including what they are, what each one is referencing when it comes to product and application design, and examples of each.

I will also discuss the selection and use of color in design. Finding the right colors that promote the correct emotions in people is only the first step because you also have to make sure that the colors work well together.

And the final topic will be typography. People may already know the difference between a Serif font and a Sans Serif font, but you should also know whether or not you can use both types in a single application or how many different fonts should be used in an application.

We use cookies and sessions every day for authentication, identification, and personalization, but how do they really work? We'll dig into HTTP, the Rails internals that make things easy, and some ideas on keeping your web app secure.

This interactive presentation will cover many of the building blocks of modern security, with an emphasis on cryptography. Topics include encryption, hashing, passwords, injection, session management, and developer security. Dev-ops topics (such as server security, cloud hosting, application stacks, etc.) and higher-level concepts (OAuth, cross-site scripting, architectures) will be also be touched on if requested. Ideally, each topic will be a relatively dense 5 minute overview hitting the core theory along with code samples. Topics will be chosen by audience participation (bring your voices.)

Details for the talk will be taken from my experience, academia, OWASP, Security Now, and an assortment of security-focused presentations and papers. The talk will assume little to no prior security knowledge, though we won’t spend much time on anything you already know.

Communication between parts of a distributed system can add complexity and constraints to already complex systems. When the communication protocols tightly couple the components, ensuring configurable scalability and availability can be difficult. Messaging offers a flexible solution to decouple the components of distributed systems. I'll present how messaging works, show how it is implemented within an application, and talk about how I've used messaging to solve some real-world problems.

WordPress is the most popular content management system built from PHP and MySQL. It speeds up the website development process, and helps developers create websites that clients can manage on their own. For developers who have been looking to get more efficient through use of a CMS, this session should prove very helpful. By the end of the session, attendees will know how to install WordPress at a good host; choose, install, and configure a theme; choose, install, and configure key plugins; and how to own a WordPress site ongoing (updates, content creation, SEO, etc.).

Qyoto is a language binding of the Qt framework and helps to bind the C# language to the Qt GUI C/C++ framework. This talk will provide an introduction to the Qyoto framework and will take a close look at how a developer can use Qyoto to develop apps for Mac OS X, Linux and Windows. The talk will also expose the Qt concepts of Signal/Slot and Qt MVC concept using Qyoto. In this talk, I will show campers an example of how to deploy a simple app using Qyoto on the Linux, OS X and MS Windows platform to collect event data from a meetup event. If time permits, I'd also like to cover some of the Qt Android work that has been going on with the Ministro and Necessitas SDKs. These SDKs are opening a lot of opportunities to port existing Qt apps to the Android tablet and phone. Talk Time Outline (10 mins) Background Behind Qt, Qt Platform, and Qyoto (10 mins) Introduction to Mono (10 mins) Go over simple code example of Hello world using MonoDevelop (10 mins) Show simple Qyoto app using the

You have heard the arguments. When you get down to it, it is all IL, right? Doesn't that make C# and F# the same Hogwash! In this talk, we will explore those areas where F# has distinct advantages over F#, including:

• Immutability by default
• Domain on a page
• Pattern matching
• Computation expressions
• The eradication of null

Use what you learn from this talk to be able to, very confidently, make the case for F# to your friends, your colleagues, and greater "powers-that-be". Or at least understand why you should stop putting off that nagging "finally learn F#" to-do item that has been in the back of your head all these years.

A geofence is a virtual perimeter around a location of interest and, as of iOS 5, developers can utilize geofences to offer a new range of location-aware features in their apps. In this session we will learn the basic concepts behind geofencing and how to integrate geofencing into iOS apps.

The new standard of C++ has been ratified, and it only took 8 years! C++11 contains tons of new features -- this talk will focus on the new concurrency-related features of C++11, including lambdas, auto, threads, and futures. We'll also discuss how C++11 integrates with Microsoft's own concurrency efforts, in particular asynchronous and parallel programming using Tasks and the PPL (Parallel Patterns Library).

In a world of chaotic language wars, a new contender takes a stand, in a valiant fight.. to the death!! Go is not only capable but ideal for the domains that are currently occupied by Python, Ruby, Rails, Clojure, C, and C++. Web apps, command-line tools, even sophisticated GUI frameworks are the perfect use-cases for this up-and-coming language.

We'll discuss some features that Go brings to the table, some that it intentionally omits and why, and the philosophy and reasoning behind Go that makes it one of the best languages we have available.

jQuery plugins are great for standalone features, but when your client-side code base starts to grow and your Javascript moves beyond one-off actions, you need ways to organize your code.

Don't reinvent the wheel! Instead, come learn about common GUI design patterns like Data Bindings, Observers, Event Aggregators, as well as what MVC really is.

We'll talk about how the theory behind these patterns, how to use them in practice, and how they are used in popular frameworks like Backbone.js and Ember.js.

If you've read anything on Test Driven Development you know the process works like this:

• Write a little test.
• Write a little code.
• Refactor
• Profit happily while working 40 hour weeks on bug free code, never being confused or stumped, and riding a Unicorn to work.

Right. It doesn't work that way. We all know it.

TDD in any framework, let alone one as tightly coupled as Cocoa is, can be an exercise in sheer frustration. Code that can't be tested, code that takes forever to test, and This is exacerbated by sample code and frameworks that either don't have TDD in mind or just use bad design practices. We'll take an irreverent tour through the real TDD design process (which goes TDTDTDFUUUUUU) and show ways to truly Refactor you code to take advantage of the benefits of testing without nearly as much difficulty.

This session will introduce tools and techniques to build web and deploy web sites from the ground up in Clojure. Joodo will the tools of choice. We'll see how is to makes web development easy. And watch out for the paradigm shift. As a functional language, Clojure requires fundamentally different approaches to solving problems. We'll have fun comparing and contrasting.

In this hands-on session, attendees will get an introduction to developing Chrome extensions/applications and test drive their solution using Jasmine.

Please bring your laptops!

While the new Web Deployment Features have made deployments of .NET Web Applications easier, for other application types (such as WPF, Windows Services, and Windows Forms) “Windows Installers” (MSI files) are often the best alternative. Since Visual Studio 11 will no longer provide the "Setup Project Type" to easily create MSI’s .NET developers will need to consider other options. While there are some powerful (and expensive!) commercial products to do this - one free alternative is the Open Source Windows Installer XML Toolkit (WIX). While WIX has a steep learning curve (as the MSI’s themselves are quite complex) WIX is a viable alternative given its strong features set and high level of support. This presentation will give an introduction to WIX and show how to create an install (and configuration) for a Windows Service, an install for Windows Client (and its shortcut) with considerations for handling configuration files and automated build.

It seems like every week a new JavaScript framework is being raved about in the Twitterverse. What is a JavaScript framework? What benefits would I get from using a JavaScript framework? I am an ASP.NET MVC developer; can I use a JavaScript framework?

In this talk Keith will answer all of these questions and dive into one of the most popular JavaScript frameworks; Knockout. Keith will cover how you using the power of Knockout you can make your ASP.NET MVC Views more object oriented, responsive and maintainable.

Mozilla's Open Badges project (http://openbadges.org) is an effort to recognize life long learning. Learning happens everywhere, not just in the classroom, skills learned on the job, online, or in self-directed pursuits should be acknowledged. Badges help solve the problem, Mozilla Open Badges allow for the issuing of portable, transferable badges that a learner has total control of. Organizations like NASA, Pixar, and the Smithsonian are all working on OpenBadges compliant badging systems, but the system is easy enough that even a small site can issue a compliant badge. We'll talk a bit about the history of Open Badges, how to integrate them into your own projects, and how to contribute to the wider emerging learning ecosystem.

• The Open Badges infrastructure (OBI) is an open source project on Github, http://github.com/mozilla/openbadges.
• The OBI is built on the Node.js and Express.
• We're using Mozilla's Persona / BrowserID system for authentication

Class, superclass, metaclass, singleton class, eigenclass, class <<self, class Class, Class.new. We all know that Ruby is an object oriented language, and specifically it is a class based language. One of the strengths of Ruby is that it can be extremely usable without having to really understand what's going on behind the scenes. Drift from the happy path, however, and you can find yourself wandering in a dream-world of class<<self or trying to grok the difference between 'include' and 'extend'. This talk will try to explain why we have classes and metaclasses, and how it all hangs together (and a bit about the movie Inception, to keep things from getting too boring.)

note: this will be presented at ChicagoRuby

This will be similar to the event at the Chicago Node.js meetup.

Come prepared to write some code! This workshop will focus on building features on top of an existing, small project. Attendees will form teams (or go solo) and take tasks to work on. Instructors will be available to answer questions and discuss design decisions.

Tasks will range from easy to hard. You can also come up with your own features and implement them.

The purpose of this workshop is to get comfortable dealing with (1) other people's Node.js code, (2) the Github workflow, (3) Open Source in general.

When you complete your task, we can merge it into the repository and test it out! If you don't complete it before leaving, you can keep working on it and submit a pull request whenever you finish.

Requirements:

• passing familiarity with node.js

• installed node.js for your OS

• a github.com account

As Node's popularity grows, the "Holy Grail of Web Development" is within reach -- writing application code once and executing it both on the server and in the browser! I will share lessons I've learned from building out the Drumkit.js code-sharing framework and show how we are using Node at Groupon to quickly build new Web applications with shared data models, view logic and request routing.

Building high performance applications has become more difficult as CPU speeds have maxed out and CPU cores have increased. Threading by itself works well for long running tasks and parallelization libraries are good for large data throughput. This talk will bring together ideas about functional programming in everyday languages and managing an application as a task pool. I will show how to avoid the usual threading issues (race conditions, deadlocks, etc.) by using idempotent methods and immutable objects. Threaded programming isn't hard if you follow simple rules during development.

Focus topics: Threading, immutability, functional programming, and unit testing threaded code. Mostly .NET examples, but should translate easily to other object oriented languages.

You're an application developer, not a plumber (or carpenter), so why are you writing your own MVVM framework? Worse yet, maybe you're jamming all sorts of code in the code-behind! Put down the pipe wrench (or hammer) and pick up one of the best MVVM frameworks for WPF/Silverlight/WP7. Caliburn.Micro makes it extremely simple to create solid, testable applications, while also reducing the amount of code you have to write.

How do we make our software more flexible and adaptable to changes, both functional and technical? What we need is software that can stretch and contract like a bungee cord when necessary. By using elastic design in our software we can achieve this flexibility. This session will discuss and demonstrate what elastic design is and how to use it in your applications.

I will walk through how you can use schema-less databases to increase the flexibility of your persistence, how to create RESTful interfaces to allow dynamic and elastic interactions between two endpoints, and how you can use cloud-based platforms to take advantage of their elasticity to allow your application to grow with little effort from you. We will then tie these together to show how they all work together in creating elastic applications.

In this session we'll take a quick tour of Windows 8 and then turn our attention to developer issues and tools. Topics of discussion will include Desktop vs. Metro, .NET vs. WinRT, touch vs. mouse & keyboard, XAML vs. HTML, and more. Whatever your preferences, this presentation should help prepare for the future of Windows.

Take your .NET know to SharePoint. Go through the steps of creating a WebPart, adding it to a SharePoint page and finally connecting two WebParts so you can pass information from one WebPart to the other.