Former DoubleClick Founder and CTO Dwight Merriman wrote the first lines of MongoDB code in 2007. He drew upon his experiences building large scale, high availability, robust systems to create a new kind of database. This session will introduce the history and philosophy of MongoDB, as well as a few key use cases.

This talk will introduce the features of MongoDB by walking through how one can building a simple location-based checkin application using MongoDB. The talk will cover the basics of MongoDB's document model, query language, map-reduce framework and deployment achitecture.

This talk will contain 2 topics: 1) How to monitor your MongoDB cluster and what to look out for to prevent explosions. 2) How to build a redundant, scalable queuing system using MongoDB.At Boxed Ice we throw 3.5TB of data into MongoDB each month, which results in processing billions of documents. Fun times.

One of the challenges that comes with moving to MongoDB is figuring how to best model your data. While most developers have internalized the rules of thumb for designing schemas for RDBMSs, these rules don't always apply to MongoDB. The simple fact that documents can represent rich, schema-free data structures means that we have a lot of viable alternatives to the standard, normalized, relational model. Not only that, MongoDB has several unique features, such as atomic updates and indexed array keys, that greatly influence the kinds of schemas that make sense. Understandably, this begets good questions: Are foreign keys permissible, or is it better to represent one-to-many relations withing a single document? Are join tables necessary, or is there another technique for building out many-to-many relationships? What level of denormalization is appropriate? How do my data modeling decisions affect the efficiency of updates and queries? In this session, we'll answer these questions and more, provide a number of data modeling rules of thumb, and discuss the tradeoffs of various data modeling strategies.

With the release of 1.8, MongoDB supports write-ahead journaling of operations to facilitate fast crash recovery and durability in the storage engine. In this session, we'll give an overview of durability with MongoDB, demo journaling, and discuss journaling internals.

guardian.co.uk is a leading UK-based news website. We've spent ten years fighting relational database representations of our domain model, until the implementation of our API made us realise that if only we could store documents everything got simpler. I'll talk about the history that led us to choosing MongoDB as a key part of our infrastructure going forward and how we're progressively migrating from our relational database.

Databases are not getting the love they deserve from Platform-as-a-Service. They are finicky, difficult to write to and notoriously resistant to scale. Not so Mongo. It is easy and it scales. And if managing routers, shards and all those replica gets in the way, PaaS is there to the rescue! This talk shows how we turn Mongo quite literally into a checkbox on Red Hat's newly announced OpenShift Flex platform. We'll look at how users can start with a cost-effective, single-node deployment and then auto-scale to a multi-node setup for high performance when needed, all the while retaining full control over the deployment architecture.

MongoDB works great with Python. This talk will be about building real-world Web applications using Pylons and its successor, Pyramid. We will cover some of the nitty-gritty details of how to integrate MongoDB with these Web frameworks, discuss what is new in Pyramid, and also go into some more advanced topics such as geo-spatial indexing, third-party authentication and social graph-type queries - which you will likely find useful in any serious project. We'll also talk about best practices for a production deployment of Python Web applications alongside MongoDB.

Puzzled about how you go from 3rd normal form to a JSON representation? Should foreign key relationships be modeled as an embedded array of documents or links? What should I index and when are indexes best applied? Is de-normalization totally bad? All these questions are more will be answered as we white board you through a simple schema design, build queries and indexes, morph the design based on new requirements and show the simplicity of using JSON to represent your applications data. Bring your favorite modeling problem and we will provide the white board and pens to figure out a solution for you!

This talk goes over various performance tuning techniques used in real world examples from our implementation of MongoDB at Shutterfly. We will cover various techniques including usage of the profiler, query tuning, monitoring for performance, data-modeling, data locality, and hardware setup

Looking to store and query location data? MongoDB has you covered. Learn how to structure, and even shard your geo data, along with an unlikely use case: an infinitely large board game!

Come listen to Scalr co-founder Sebastian Stadil talk about what it takes to set up automatic scaling of MongoDB, so more capacity is added when load increases, capacity lowered when load subsides, including what OS- and API- level metrics work best. And if the audience is in a good mood: bonus intro to setting up multi-cloud, fault-tolerant web apps reliant on Mongo!

Schema design is a critical step in making sure an application scales well. There are considerations for reads and writes, both with and without sharding. We'll go through a few use cases and examine how difference schemas impact performance.

An introduction to working with MongoDB and C#. This talk will cover the basics of the official C# driver from installation, connecting to mongod and basic CRUD operations. We will also talk about some upcoming features in the driver.

Puzzled about how you go from 3rd normal form to a JSON representation? Should foreign key relationships be modeled as an embedded array of documents or links? What should I index and when are indexes best applied? Is de-normalization totally bad? All these questions are more will be answered as we white board you through a simple schema design, build queries and indexes, morph the design based on new requirements and show the simplicity of using JSON to represent your applications data. Bring your favorite modeling problem and we will provide the white board and pens to figure out a solution for you!

MongoDB supports replication for failover and redundancy. In this session we will introduce the basic concepts around replica sets which provide automated failover and recovery of nodes. We'll show you how to set up, configure, and initiate a replica set, and methods for using replication to scale reads. We'll also discuss proper architecture for durability.

Demand Media web property eHow gets 100MM+ unique users on a large content database. MongoDB is perfectly suited for content management: the document model exactly matches our delivery model of documents and pages. The Demand Media team rewrote the legacy inherited .NET/SQL system to PHP/Python/MongoDB in a cachless, tierless design, all on one machine with replication. It's a big win -- eHow.com can take all of its traffic on a single machine.

Learn the nitty gritty details of all the options in the shell, and how to best leverage them. Lots of examples and sample code will be provided.

Wordnik has built a directed graph containing all words in English. This runtime graph is backed entirely by MongoDB and is enabled by Mongo's speed and document-oriented storage features. During this talk, Tony will discuss some of the tricks that were used by Wordnik to address both speed and scalability.

We're working on a new aggregration framework for MongoDB that will introduce a new aggregation system that will make it a lot easier to do simple tasks like counting, averaging, and finding minima or maxima while grouping by keys in a collection. The new aggregation features are not a replacement for map-reduce, but will make it possible to do a number of things much more easily, without having to resort to the big hammer that is map-reduce. After introducing the syntax and usage patterns for the new aggregation system, we will give some demonstrations of aggregation using the new system.

Last fall I spoke at the MongoSV conference about using MongoDB for the historical archive at Craigslist. Since then we've successfully migrated roughly 2.2 billion documents into a MongoDB deployment using sharding and replica sets. This session will briefly review the motivation for this migration and focus on lessons learned along the way, including MongoDB features we wished we had and how to think about undertaking a data migration project of this size.

Matching data coming from multiple external and internal sources is challenge for any IT organization across industry verticals like Retail, Manufacturing, Banking, etc. The problem statement is becoming more and more daunting given recent trends of B2B, B2C, B2P business ecosystem using loosely coupled business interfaces of SoA where agility and flexibility are keys. In the proposed presentation we would take a look on how MongoDB's document based schema is a natural fit to build a robust Data Matching Engine addressing this business challenge and how MongoDB's MapReduce feature provides the necessary scale of tackling large volume Data Matching load. We'll also touch upon on the scalability metrics which can be achieved using MongoDB's distributed computing features like sharding, replica sets, delayed replication etc.

A discussion of how we built a .NET based streaming analytics engine using Mongo - why upserts, shards were critical and how we integrated Mongo with relational databases and MSMQ for high performance and a great user experience.

The Spring Data project provides sophisticated support for NoSQL datastores. The MongoDB module consists of a namespace to easily setup MongoDB access, a template class to provide a nice API to persist and query objects as well as sophisticated support to build repositories accessing entities stored in a MongoDB. The talk will introduce the Spring Data MongoDB support and present the features in hands on demos.

JS is use in many places in Mongo: the shell, map/reduce, grouping, eval queries, etc. Let's take some time to talk about how Mongo is interfacing with JS, what JS engine is used, and how to best use the features that rely on JS. This talk will also include some of the upcoming improvements slated for map reduce and JS in general. Many questions welcome.

With MongoDB, you can distribute load across multiple servers using auto-sharding. This session will introduce MongoDB's auto-sharding concepts and how to use them. We'll discuss choosing a shard key, basic architecture concepts, and common usage patterns. We'll close out the session with a few example use cases, including real world sharded deployments.

At MongoSF last year, Dwight Merriman demoed what was then the beta version of Replica Sets. In this session, Dwight will cover many of the new features implemented since last year's session: slave delay, initial sync from a secondary, hidden servers, freezing members, fast sync, and more. We'll also examine the oplog, and the mechanics of replica sets voting and priorities.

An overall introduction to GeoSpatial querying support in MongoDB, along with a tour of some of the new features introduced in 1.9.

That's right: you too can learn to read the omens and ensure that your MongoDB deployment stays in tip-top shape. We'll look at memory usage, file sizes, flushing, journaling, and all the special incantations that reveal MongoDB's true inner self. By the end of the talk, you'll have ten concrete steps you can take to address performance degradation before it happens. You'll also get a few tips on application design and pointers on remote monitoring.

The need: We were pivoting Mashape, we had 30 days to completely change our product and release a new version, and we needed a scalable and flexible solution (schema-free) well supported by the community, that we could easily implement. Also, we were looking for a solution that had success stories. I created my first MongoDB-powered app in two nights, that surprisingly had thousands of page views. The app behaved so well, and the implementation was so easy, that I decided MongoDB was the right solution for us. The first version of Mashape was using Hibernate and MySQL, and it was a pain: it took a long time to have all perfectly working. With MongoDB and morphia we made our implementation in less than a week. And with a schema-free solution, we now have the flexibility we need.

We'll have an in depth discussion about mongo indexes. In this small group session and we'll focus on topics of particular interest to those in attendance - so bring questions!

Foursquare is a location based social network that incorporates gaming elements. foursquare uses MongoDB to store venues and user ""check-ins"" into venues, sharding the data over more than 25 machines on Amazon EC2.

In this talk we will discuss a new design pattern for building applications that consist of many small apps that work together to appear as one website. Cloud Foundry is a PaaS that supports many languages and frameworks as well as many services and data stores, one of which is MongoDB, We will talk about a new pattern enabled by this architecture where you can write different pieces of your application in multiple different languages or frameworks and use a shared MongoDB instance provided by Cloud Foundry's data service layer as an integration point between all the app parts. Not only can you store data in MongoDB for display on the web pages of your app, but you can use MongoDB as a message queue or logging device between apps as well as a shared data structure container. So with this pattern you could have written your main application ui in Ruby on Rails but you may have a few web services or applets written in sinatra or node.js as well as perhaps a Spring java application doing some heavier number crunching or data processing. And use Mongodb via Cloud Foundry's Services layer as an integration point between all the pieces of this application in order to make it appear as one app to the outside world.

At Loggly we use MongoDB as a repository of statistics. We collect data on both the size and count of incoming events by originating ip and destination. These statistics on incoming events are used to drive the dashboards on the front page of every Loggly customer sub-domain that break down the last 24hrs of data flow by input and ip. This allows customers to get usage and flow information at a glance the minute they login without having to run solr searches across our indexes. We'll talk about how we tied Mongo into our infrastructure, and how we expose the data to the end users via our REST APIs.

I will talk about IGN's Social Platform Architecture in context of MongoDB utilization. The talk will cover the social platform modules where IGN evaluated NoSQL solutions and picked MongoDB. These modules include activity streams, activity comments, notifications and other read/write heavy components. I'll also discuss the deployment, monitoring and future plans regarding MongoDB at IGN beyond the Social Platform.

A (brief?) introduction to working with MongoDB and Python. This talk will cover the basics from installing pymongo and connecting to mongod to creating, inserting, querying for, and updating documents. We will also briefly touch on aggregation, geospatial indexes, GridFS and running database commands.

Indexes, what Indexes?

B-Trees, Sparse and Covered indexes and how MongoDB uses them still confusing you? In this talk we will dive into the different indexes that are available, how query plans are executed and the internals of index evaluation including understanding of the explain output.

This session is a deep dive into the implementation of sharding within MongoDB. We'll review the MongoDB's sharding architecture, which blends ideas from RDBMSes, key/value stores, and large distributed systems like BigTable. We'll then take a look "under the hood" to show how queries work across a sharded set up, and how data is balanced and migrated.

Jump on board to learn about combining two of the most exciting technologies to quickly build realtime apps yourself. This talk will introduce the popular Node.js library, Mongoose, which is a MongoDB "ORM" for Node.js. First, the speaker will deliver a quick primer on Node.js. Then, he'll walk you through Mongoose's schema api, powerful query builder, middleware capabilities, and exciting plugin ecosystem. Finally, he'll demonstrate some realtime capabilities using Node.js and Mongoose.

This talk presents the best ways to use MongoDB from Ruby. We'll look at the Ruby driver, the Ruby MongoDB community, and some ideas about object mappers. Other topics to be covered will include JRuby, multi-threading, replica sets, write concern, and future plans.

Understanding the database working set size of an application is critical to understanding performance and having good reliability. This session will discuss working set sizes in databases, estimating the size, and discuss solutions for different sizing various scenarios.

MongoDB has been designed for versatility, but the techniques you might use to build, say, an analytics engine or a hierarchical data store might not be obvious. In this talk, we'll learn about MongoDB in practice by looking at four hypothetical application designs (based on real-world designs, of course). Topics to be covered include schema design, indexing, transactions (gasp!), trees, what's fast, and what's not. Sprinkled with tips, tricks, shoots, ladders, and trap doors, you're guaranteed to learn something new in this interdisciplinary talk.

MongoDB runs great in the cloud, but there are some things you should know. In this session we'll explore scaling and performance characteristics of running Mongo in the cloud as well as best practices for running on platforms like Amazon EC2.

We've just released the code for the sourceforge.net beta, which is powered by MongoDB and takes a unique document oriented approach to Ticket tracking, Wiki Pages, SCM data, and all of the other tools that software development projects need to organize and align their efforts over time. The result is a system where it's easy to record an audit trail, easy to manage huge amounts of data, and easy to add new features.

• Building a reporting back end with Mongo (Chris Carrier)
• Serving Data to Mobile Apps with MongoDB (Michael Goff, Cocoafish)
• Simple Scalable Cloud-based Workers (Chad Arimura, SimpleWorker)

A more in-depth look at how MongoDB manages your sharded collections and handles configuration changes.