Level 200: Scaling Applications: Complexity, Performance, Maintainability
We are building the same types of systems as we built yesterday, the demands placed on our systems becomes more and more demanding. We need to handle more users, offer more intelligent behavior, parallelize both development and deployment, handle partial failures in our applications,offer the operations team rich insight into our systems and the ability to tweak them at runtime and so much more.
Trying to build such application using the standard N-tiered architecture has proven to be hard, challenging and complex. In this session, you will learn how changing some of the underlying architectural concepts in how we build applications can lead to simpler solutions that scale extremely well. Those concepts include divide and conquer, background evaluation, one way messaging and ruthless application of the single responsibility principle.
In the .Net space, there are several frameworks and patterns that you can use, and which will demonstrated in this session (including Rhino Service Bus, NHibernate and Windsor), to build these sort of systems.Edit
Level 300: Rhino Service Bus
Our systems become more and more complex at the same time that we have much stricter requirements for performance and scalability. Those two opposing forces make it very hard to build system in a way that is maintainable, sustainable and performant. Rhino Service Bus is an application server with one way async messaging at its core. By doing so, Rhino Service Bus enables you to build systems that are compose of independent services working together to achieve a common goal, while keeping each service simple and independent. In this talk, we will discuss Rhino Service Bus, the architecture that it support and how you can utilize it to build high scalability systems with vastly reduced complexity than the standard methods.Edit
Level 200: That NoSQL Thing
As we scale our system, we run into the inherit limitations of the RDBMS platform. At some point, it is simply not feasible to scale an RDBMS system and at a much earlier point, it isn't economic to do so.
In this talk, we will discuss the move away from relation database and explore several NoSQL data stores, including Key/Value stores, Document Databases, Graph Databases and Column Family Databases.
We will focus specifically on the performance and scalability enhancement that can be derived from using a NoSQL database, and the difference in the architecture that are required to fully utilize a NoSQL database.Edit
Level 200: Lessons learned from building the NHibernate Profiler
The NHibernate Profiler is an application that can track what an NHibernate based application can do. Building a real world application is never as simple as building demo apps, and there are many concerns that you have to consider when you do build something that will be used in the wild.
In this talk, we will go over the implementation and design decisions, hurdles that we had to overcome and the challenges that needed to be resolved. Along with the technical details, we will discuss working in a distributed team, creating a product and all the other things that you have to do in order to create a software product that you can actually sell.
Level 200: Producing Production Quality Software
Working software is no longer the only thing that we need to produce. We need to create a software system that has a chance of surviving in the cruel world of production system, outside the clean room and sterile environment of development and QA. Understanding bottlenecks in the system, preventing cascading failures and recovery strategies have ceased being the problems of the very high end players. With the cost of system downtime being measures in $$$/second, this is an area we have to consider all the way.
In this talk we will cover how we can map common weaknesses in the system design, preemptively protect ourselves from them, and produce software systems that can withstand the real world hostile environment.Edit
Level 300: Building Multi Tenant Applications
Our applications are only getting more complex over time. Different clients want different things, and we have to satisfy them all. Building applications that we can grow organically, that we can customize, fit and modify for particular clients and for particular needs is becoming more and more important. If you are writing application for Software as a Service or have to deal with the non trivial challenges of building maintainable enterprise software, you have already had to deal with significant complexities.
In this session, we will cover the basics of building such systems, from building dynamic data models to customizing behaviors and adaptable user interface.Edit
Level 200: Building Scalable Systems
We aren't building single user systems anymore. If fact, we are building systems that needs to handle hundreds of thousands or millions of users. The methods that we used to build low scalability applications are not applicable when we want our applications to scale.
In this session, we will talk about scalability hinderances, designing for scalability and look into some of the constraints that building scalable systems place on us. Edit
Level 200: Building Zero Friction Development Environment
Development is a fun process, most of the time. But in any development environment, we have areas where we have friction points that we have to deal with. If it is the pain of having to add a column to the database, or taking three weeks in order to deploy to production. It doesn't have to be like this. Being conscious of those friction points and actively eliminating them is a key to creating sustainable development environment and keeping our software design from being corrupt by "quick fixes" or hacks.Edit
Level 4/300:Object Relational Mapping += 2: More then just data <-> object
Object relational mapping are becoming only more popular, as people developing complex systems find that they need more than the tabular model to work with in their applications. A sophisticated ORM can do a lot more than merely get the data out of the database in object form, it can be a valuable assest in simplifying development and making things possible. In this session, you will see how you can utilize an ORM in untraditional ways to get an additional, better, approach to solving complex issues.
Some of those ways include business rules, localization, state transitions, inversion of control, etc. All done via the ORM layer, and all can be used to drasticly simplify the complexity of the given scenarios.Edit
Level 100: Using Active Record to write less code
What would you say if I told you that you can stop writing data access code in .Net? Aren't you tired of writing the same thing over and over again, opening connection, querying the database, figuring out what to return, getting back untype data that you need to start putting on the form? Do you really see some value in writing yet another UPDATE statement?
The Active Record framework allows you to fully utilize the power of the database, but without the back breaking work that it used to take. Active Record uses .Net objects to relieveyou from the repeating task of persistance. Those objects are schema aware and can persist and load themselves without you needing to write a single line of SQL. Building business application using Active Record is a pleasure, the database stuff just happens, and you are free to implement the business functionality.
Level 200: Rapid (maintainable) web development with MonoRail
If you're a fan of Ruby on Rails and want to see similar capabilities in .NET, or you're an ASP.NET developer looking for an easier way to do things, MonoRail will be irresistible once you find out what it can do for you. Strong support for Ajax makes writing buzzward compliant web applications a breeze. Utilization of the Model-View-Controller architecture and convention over configuration makes web development with MonoRail a pleasure. Free yourself from page-life cycle issues and viewstate worries, start working with MonoRail, where the framework works for you.
This talk will introduce the general concepts of the framework, and how you can use themEdit
Level 100: Interaction based testing With Rhino Mocks
Beyond the simplest scenarios, all objects had collaborators that they work with. This flies in the face of testing objects in isolation. This is the problem that mock objects were created to solve. In this talk you will learn what mock objects are, how to utilize them and best practices on when / how to utilize them. Rhino Mocks is a mock objects framework for .Net whose core goals are to let the developer rely on the compiler work well with refactoring tools.Edit
Level 200: Inversion of Control and Dependency Injection: Breaking out from the dependecy hell
Responding to change is the holy grail of software development. Inversion of Control (IoC) and Dependency Injection (DI) are two related patterns that allows to make significant changes to an application without having to touch every part of the application. IoC and DI encourage breaking the application into discerete, highly cohesive parts, so a change, when it eventually comes, is very local. A nice benefit is that applications that uses IoC are also very testable applications.
This talk will introduce the concepts of IoC and how to use them in your application.
Level 4/300: Advance usages of Inversion of Control containers
You already understand the concepts of Inversion of Control and Dependency Injection, now is the time to see how far we can make the IoC container works for us. This talk will focus on using an IoC container in complex scenarios. We will talk about generic decorator chains and generic specialization, contextful containers and IoC DSLs. These powerful concepts can greatly enhance your ability to respond to change in your application.Edit
Level 300: Writing Domain Specific Languages in Boo
Domain Specific Langauge is not just the DSL SDK from Microsoft. A DSL can make working with the domain much easier, since you are capable of leveraging the domain concepts directly. The other alternative to a DSL is an XML file, and we all know how well declarative model can work when you need imperative concepts, just consider NAnt for a minute and you will see the issue. Usually, writing a DSL in .Net would be a complex issue, requiring writing a parser, interpreter, etc. Boo already handles all of that, and its open architecture means that it is very easy to extend it to express the concepts of the domain. This talk will show you how to build DSLs in Boo and how to utilize this power in your applications.