Brendan McAdams explores the deeper relationship between the MongoDB database and various languages on the Java Virtual Machine such as Java, Scala, Clojure, JRuby and Python as well as the challenges posted getting MongoDB to play nice with these tools and their syntax. Also examined will be frameworks and integration points popular between MongoDB and the JVM such as Spring Data, Morphia and Lift’s MongoDB-Record component
Intro to MongoDB
Get a jumpstart on MongoDB, use cases, and next steps for building your first app with Buzz Moschetti, MongoDB Enterprise Architect.
@BuzzMoschetti
This document discusses MongoDB and common use cases for NoSQL databases and MongoDB. It provides examples of flexible data models in MongoDB and how it enables high data throughput, handling of big data, and low latency. Specific use cases mentioned include high volume data feeds, operational intelligence, behavioral profiles, product catalogues, content management, and metadata. MongoDB is presented as a good fit for applications that involve large numbers of objects, high read/write throughput, low latency needs, variable data in objects, and cloud-based deployment.
The Right (and Wrong) Use Cases for MongoDBMongoDB
The document discusses the right and wrong use cases for MongoDB. It outlines some of the key benefits of MongoDB, including its performance, scalability, data model and query model. Specific use cases that are well-suited for MongoDB include building a single customer view, powering mobile applications, and performing real-time analytics. Cache-only workloads are identified as not being a good use case. The document provides examples of large companies successfully using MongoDB for these right use cases.
Conceptos básicos. Seminario web 6: Despliegue de producciónMongoDB
Este es el último seminario web de la serie Conceptos básicos, en la que se realiza una introducción a la base de datos MongoDB. En este seminario web le guiaremos por el despliegue en producción.
The document discusses schema design considerations for modeling data in MongoDB. It notes that while MongoDB is schemaless, applications are still responsible for schema design. It compares relational and MongoDB schema designs, highlighting that MongoDB uses embedded documents, has no joins, and requires duplicating or precomputing data. The document provides recommendations like combining related objects, optimizing for specific use cases, and doing aggregation work during writes rather than reads.
PgREST allows running Node.js modules inside PostgreSQL for building a JSON document store with existing relational data while being compatible with MongoDB APIs. It utilizes various PostgreSQL extensions and tools like PLV8, plv8x, and OneJS to enable JavaScript functionality within the database for code reuse across browser, server, and database applications. The document provides examples of using PgREST to load modules, run JSON queries, and integrate Node.js functionality directly inside the database.
Intro to MongoDB
Get a jumpstart on MongoDB, use cases, and next steps for building your first app with Buzz Moschetti, MongoDB Enterprise Architect.
@BuzzMoschetti
This document discusses MongoDB and common use cases for NoSQL databases and MongoDB. It provides examples of flexible data models in MongoDB and how it enables high data throughput, handling of big data, and low latency. Specific use cases mentioned include high volume data feeds, operational intelligence, behavioral profiles, product catalogues, content management, and metadata. MongoDB is presented as a good fit for applications that involve large numbers of objects, high read/write throughput, low latency needs, variable data in objects, and cloud-based deployment.
The Right (and Wrong) Use Cases for MongoDBMongoDB
The document discusses the right and wrong use cases for MongoDB. It outlines some of the key benefits of MongoDB, including its performance, scalability, data model and query model. Specific use cases that are well-suited for MongoDB include building a single customer view, powering mobile applications, and performing real-time analytics. Cache-only workloads are identified as not being a good use case. The document provides examples of large companies successfully using MongoDB for these right use cases.
Conceptos básicos. Seminario web 6: Despliegue de producciónMongoDB
Este es el último seminario web de la serie Conceptos básicos, en la que se realiza una introducción a la base de datos MongoDB. En este seminario web le guiaremos por el despliegue en producción.
The document discusses schema design considerations for modeling data in MongoDB. It notes that while MongoDB is schemaless, applications are still responsible for schema design. It compares relational and MongoDB schema designs, highlighting that MongoDB uses embedded documents, has no joins, and requires duplicating or precomputing data. The document provides recommendations like combining related objects, optimizing for specific use cases, and doing aggregation work during writes rather than reads.
PgREST allows running Node.js modules inside PostgreSQL for building a JSON document store with existing relational data while being compatible with MongoDB APIs. It utilizes various PostgreSQL extensions and tools like PLV8, plv8x, and OneJS to enable JavaScript functionality within the database for code reuse across browser, server, and database applications. The document provides examples of using PgREST to load modules, run JSON queries, and integrate Node.js functionality directly inside the database.
MongoDB Days Silicon Valley: Jumpstart: The Right and Wrong Use Cases for Mon...MongoDB
Presented by Sigfrido Narvaez, Senior Solutions Architect, MongoDB
Experience level: Introductory
When it comes time to select database software for your project, there are a bewildering number of choices. How do you know if your project is a good fit for a relational database, or whether one of the many NoSQL options is a better choice? In this session you will learn when to use MongoDB and how to evaluate if MongoDB is a fit for your project. You will see how MongoDB's flexible document model is solving business problems in ways that were not previously possible, and how MongoDB's built-in features allow running at scale.
The document provides an overview of MongoDB and how it can be used practically with Ruby projects. It discusses how MongoDB simplifies schema design by allowing embedded documents that match how objects are structured in code. This avoids the need to map objects to SQL schemas. Examples are given of how MongoDB could be used for a blogging application with embedded comments and tags, for logging with capped collections, and for an accounting application with embedded transaction entries. The document also introduces MongoMapper as an ORM for MongoDB that provides an ActiveRecord-like syntax for modeling documents and relationships in Ruby code.
The document provides an overview of a webinar on transitioning from SQL to MongoDB. It introduces the presenter Buzz Moschetti and his background. It then discusses how developers currently spend their time integrating with different components and systems like databases, and how the mismatch between data at the business level versus the database level has been a long-standing problem. The document uses examples to show how MongoDB can help by allowing richer data structures and a more direct match between data in code and the database.
Introducing Azure DocumentDB - NoSQL, No ProblemAndrew Liu
Application developers support unprecedented rates of change – functionality must rapidly evolve to meet changing customer needs and to respond to competitive pressures while user populations can grow dramatically and unpredictably. To address these realities, developers are selecting document-oriented databases for schema flexibility, scalability and high performance data storage.
In this session, we will get hands on with Azure’s NoSQL document database service. Azure DocumentDB offers full indexing of JSON documents, SQL query capabilities and multi-document transactions. Learn how to get started with Azure DocumentDB and hear about some of the recent improvements to the service.
Introduction to MongoDB (from Austin Code Camp)Chris Edwards
The document provides an introduction and overview of MongoDB:
1. It discusses the NoSQL movement and how MongoDB fits as a non-relational, distributed, and horizontally scalable database.
2. The basics of MongoDB are explained, including that it uses JSON-like documents, is schema-free, and provides high performance through features like memory-mapped files.
3. An overview of MongoDB's components is given, including the mongod server process, mongo shell client, and mongos shard router. Installation, basic use of the shell, and accessing MongoDB from applications are also covered.
This document outlines an agenda for a MongoDB administration and operations training. It covers topics such as installing MongoDB, architecture, common methods, indexes, backup and recovery, replication, and security management. Interactive labs are included to demonstrate starting the MongoDB service, creating collections and inserting documents. Comparisons to relational databases are provided.
The document discusses implementing a hybrid database solution using both MongoDB and MySQL. It describes storing less frequently changing and reference data like users and products in MongoDB for flexibility, while storing transactional data like orders and inventory counts in MySQL for ACID compliance. The system keeps the data in sync between the two databases using listeners that update MySQL whenever related data is created or changed in MongoDB.
MongoDB is a document-oriented, schema-free, high-performance NoSQL database. It uses dynamic queries on JSON-like documents with various data structures and scales horizontally. MongoDB is good for high-volume data, scalability, and the web. It is less suited for highly transactional or SQL-focused workloads. Documents are stored in collections and can be queried, updated, and indexed dynamically without rigid schemas.
The document introduces MongoDB, an open-source document database that provides high performance, high availability, and easy scalability. MongoDB keeps data as JSON-like documents which allows for flexible schemas and is well-suited for applications that work with unstructured or semi-structured data. The document also discusses how MongoDB can be used in conjunction with Hadoop for large-scale data processing and analytics workloads that require more than just a document database.
Conceptos básicos. Seminario web 4: Indexación avanzada, índices de texto y g...MongoDB
Este es el cuarto seminario web de la serie Conceptos básicos, en la que se realiza una introducción a la base de datos MongoDB. Este seminario se ve en la compatibilidad con índices de texto libre y geoespaciales.
This document contains information about Justin Smestad and MongoDB. It includes Justin's contact information and background working as a software engineer with skills in Ruby, JavaScript, Clojure, and passion for DevOps. It also provides an overview of MongoDB, describing it as a scalable, high-performance, open source, schema-free, document-oriented database. Key features of MongoDB like indexing, master-slave replication, and horizontal scaling with replica sets and sharding are summarized.
Conceptos básicos. Seminario web 1: Introducción a NoSQLMongoDB
This document contains an agenda and summary for a webinar on introducing NoSQL databases. The webinar covers why NoSQL databases exist, different types of NoSQL databases including key-value stores, column stores, graph stores, multi-model databases and document stores. It also discusses MongoDB specifically, covering its document data model, indexing, querying, aggregation capabilities, replication and sharding for scalability. The webinar invites participants to a follow up session on building a first MongoDB application.
MongoDB Schema Design (Richard Kreuter's Mongo Berlin preso)MongoDB
This document discusses schema design considerations for MongoDB databases. It recommends letting the application direct the schema, judiciously denormalizing data, designing schemas for indexing, using application-level joins when needed, avoiding treating collections as unstructured heaps, and not frequently resizing documents. The document provides examples of embedding related data and storing event data in separate documents to avoid resizing.
The document introduces MongoDB as a scalable, high-performance, open source, schema-free, document-oriented database. It discusses MongoDB's philosophy of flexibility and scalability over relational semantics. The main features covered are document storage, querying, indexing, replication, MapReduce and auto-sharding. Concepts like collections, documents and cursors are mapped to relational database terms. Examples uses include data warehousing and debugging.
This document outlines the topics covered in an Edureka course on MongoDB. The course contains 8 modules that cover MongoDB fundamentals, CRUD operations, schema design, administration, scaling, indexing and aggregation, application integration, and additional concepts and case studies. Each module contains multiple topics that will be taught through online instructor-led classes, recordings, quizzes, assignments, and support.
Since its first appearance in 2009, NodeJS has come a long way. Many frameworks have been developed on top of it. These all make our task easy and quick. It is us who need to decide which one to choose? So, here is the list of top 10 NodeJS frameworks that will help you build an awesome application.
This tutorial will introduce the features of MongoDB by building a simple location-based application using MongoDB. The tutorial will cover the basics of MongoDB’s document model, query language, map-reduce framework and deployment architecture.
The tutorial will be divided into 5 sections:
Data modeling with MongoDB: documents, collections and databases
Querying your data: simple queries, geospatial queries, and text-searching
Writes and updates: using MongoDB’s atomic update modifiers
Trending and analytics: Using mapreduce and MongoDB’s aggregation framework
Deploying the sample application
Besides the knowledge to start building their own applications with MongoDB, attendees will finish the session with a working application they use to check into locations around Portland from any HTML5 enabled phone!
TUTORIAL PREREQUISITES
Each attendee should have a running version of MongoDB. Preferably the latest unstable release 2.1.x, but any install after 2.0 should be fine. You can dowload MongoDB at http://www.mongodb.org/downloads.
Instructions for installing MongoDB are at http://docs.mongodb.org/manual/installation/.
Additionally we will be building an app in Ruby. Ruby 1.9.3+ is required for this. The current latest version of ruby is 1.9.3-p194.
For windows download the http://rubyinstaller.org/
For OSX download http://unfiniti.com/software/mac/jewelrybox/
For linux most users should know how to for their own distributions.
We will be using the following GEMs and they MUST BE installed ahead of time so you can be ahead of the game and safe in the event that the Internet isn’t accommodating.
bson (1.6.4)
bson_ext (1.6.4)
haml (3.1.4)
mongo (1.6.4)
rack (1.4.1)
rack-protection (1.2.0)
rack shotgun (0.9)
sinatra (1.3.2)
tilt (1.3.3)
Prior ruby experience isn’t required for this. We will NOT be using rails for this app.
The document introduces a workshop on big data tools and MongoDB, discusses how MediaGlu uses big data for advertising by tracking user paths across different channels, and outlines an agenda covering MongoDB fundamentals, running MongoDB, and labs on shell commands, aggregation, replication, and sharding.
The document discusses MongoDB and Spring Data integration. It provides examples of creating, querying, and commenting on documents using Spring Data and MongoDB. It also covers topics like replication, sharding, and eventual consistency in MongoDB.
MongoDB Days Silicon Valley: Jumpstart: The Right and Wrong Use Cases for Mon...MongoDB
Presented by Sigfrido Narvaez, Senior Solutions Architect, MongoDB
Experience level: Introductory
When it comes time to select database software for your project, there are a bewildering number of choices. How do you know if your project is a good fit for a relational database, or whether one of the many NoSQL options is a better choice? In this session you will learn when to use MongoDB and how to evaluate if MongoDB is a fit for your project. You will see how MongoDB's flexible document model is solving business problems in ways that were not previously possible, and how MongoDB's built-in features allow running at scale.
The document provides an overview of MongoDB and how it can be used practically with Ruby projects. It discusses how MongoDB simplifies schema design by allowing embedded documents that match how objects are structured in code. This avoids the need to map objects to SQL schemas. Examples are given of how MongoDB could be used for a blogging application with embedded comments and tags, for logging with capped collections, and for an accounting application with embedded transaction entries. The document also introduces MongoMapper as an ORM for MongoDB that provides an ActiveRecord-like syntax for modeling documents and relationships in Ruby code.
The document provides an overview of a webinar on transitioning from SQL to MongoDB. It introduces the presenter Buzz Moschetti and his background. It then discusses how developers currently spend their time integrating with different components and systems like databases, and how the mismatch between data at the business level versus the database level has been a long-standing problem. The document uses examples to show how MongoDB can help by allowing richer data structures and a more direct match between data in code and the database.
Introducing Azure DocumentDB - NoSQL, No ProblemAndrew Liu
Application developers support unprecedented rates of change – functionality must rapidly evolve to meet changing customer needs and to respond to competitive pressures while user populations can grow dramatically and unpredictably. To address these realities, developers are selecting document-oriented databases for schema flexibility, scalability and high performance data storage.
In this session, we will get hands on with Azure’s NoSQL document database service. Azure DocumentDB offers full indexing of JSON documents, SQL query capabilities and multi-document transactions. Learn how to get started with Azure DocumentDB and hear about some of the recent improvements to the service.
Introduction to MongoDB (from Austin Code Camp)Chris Edwards
The document provides an introduction and overview of MongoDB:
1. It discusses the NoSQL movement and how MongoDB fits as a non-relational, distributed, and horizontally scalable database.
2. The basics of MongoDB are explained, including that it uses JSON-like documents, is schema-free, and provides high performance through features like memory-mapped files.
3. An overview of MongoDB's components is given, including the mongod server process, mongo shell client, and mongos shard router. Installation, basic use of the shell, and accessing MongoDB from applications are also covered.
This document outlines an agenda for a MongoDB administration and operations training. It covers topics such as installing MongoDB, architecture, common methods, indexes, backup and recovery, replication, and security management. Interactive labs are included to demonstrate starting the MongoDB service, creating collections and inserting documents. Comparisons to relational databases are provided.
The document discusses implementing a hybrid database solution using both MongoDB and MySQL. It describes storing less frequently changing and reference data like users and products in MongoDB for flexibility, while storing transactional data like orders and inventory counts in MySQL for ACID compliance. The system keeps the data in sync between the two databases using listeners that update MySQL whenever related data is created or changed in MongoDB.
MongoDB is a document-oriented, schema-free, high-performance NoSQL database. It uses dynamic queries on JSON-like documents with various data structures and scales horizontally. MongoDB is good for high-volume data, scalability, and the web. It is less suited for highly transactional or SQL-focused workloads. Documents are stored in collections and can be queried, updated, and indexed dynamically without rigid schemas.
The document introduces MongoDB, an open-source document database that provides high performance, high availability, and easy scalability. MongoDB keeps data as JSON-like documents which allows for flexible schemas and is well-suited for applications that work with unstructured or semi-structured data. The document also discusses how MongoDB can be used in conjunction with Hadoop for large-scale data processing and analytics workloads that require more than just a document database.
Conceptos básicos. Seminario web 4: Indexación avanzada, índices de texto y g...MongoDB
Este es el cuarto seminario web de la serie Conceptos básicos, en la que se realiza una introducción a la base de datos MongoDB. Este seminario se ve en la compatibilidad con índices de texto libre y geoespaciales.
This document contains information about Justin Smestad and MongoDB. It includes Justin's contact information and background working as a software engineer with skills in Ruby, JavaScript, Clojure, and passion for DevOps. It also provides an overview of MongoDB, describing it as a scalable, high-performance, open source, schema-free, document-oriented database. Key features of MongoDB like indexing, master-slave replication, and horizontal scaling with replica sets and sharding are summarized.
Conceptos básicos. Seminario web 1: Introducción a NoSQLMongoDB
This document contains an agenda and summary for a webinar on introducing NoSQL databases. The webinar covers why NoSQL databases exist, different types of NoSQL databases including key-value stores, column stores, graph stores, multi-model databases and document stores. It also discusses MongoDB specifically, covering its document data model, indexing, querying, aggregation capabilities, replication and sharding for scalability. The webinar invites participants to a follow up session on building a first MongoDB application.
MongoDB Schema Design (Richard Kreuter's Mongo Berlin preso)MongoDB
This document discusses schema design considerations for MongoDB databases. It recommends letting the application direct the schema, judiciously denormalizing data, designing schemas for indexing, using application-level joins when needed, avoiding treating collections as unstructured heaps, and not frequently resizing documents. The document provides examples of embedding related data and storing event data in separate documents to avoid resizing.
The document introduces MongoDB as a scalable, high-performance, open source, schema-free, document-oriented database. It discusses MongoDB's philosophy of flexibility and scalability over relational semantics. The main features covered are document storage, querying, indexing, replication, MapReduce and auto-sharding. Concepts like collections, documents and cursors are mapped to relational database terms. Examples uses include data warehousing and debugging.
This document outlines the topics covered in an Edureka course on MongoDB. The course contains 8 modules that cover MongoDB fundamentals, CRUD operations, schema design, administration, scaling, indexing and aggregation, application integration, and additional concepts and case studies. Each module contains multiple topics that will be taught through online instructor-led classes, recordings, quizzes, assignments, and support.
Since its first appearance in 2009, NodeJS has come a long way. Many frameworks have been developed on top of it. These all make our task easy and quick. It is us who need to decide which one to choose? So, here is the list of top 10 NodeJS frameworks that will help you build an awesome application.
This tutorial will introduce the features of MongoDB by building a simple location-based application using MongoDB. The tutorial will cover the basics of MongoDB’s document model, query language, map-reduce framework and deployment architecture.
The tutorial will be divided into 5 sections:
Data modeling with MongoDB: documents, collections and databases
Querying your data: simple queries, geospatial queries, and text-searching
Writes and updates: using MongoDB’s atomic update modifiers
Trending and analytics: Using mapreduce and MongoDB’s aggregation framework
Deploying the sample application
Besides the knowledge to start building their own applications with MongoDB, attendees will finish the session with a working application they use to check into locations around Portland from any HTML5 enabled phone!
TUTORIAL PREREQUISITES
Each attendee should have a running version of MongoDB. Preferably the latest unstable release 2.1.x, but any install after 2.0 should be fine. You can dowload MongoDB at http://www.mongodb.org/downloads.
Instructions for installing MongoDB are at http://docs.mongodb.org/manual/installation/.
Additionally we will be building an app in Ruby. Ruby 1.9.3+ is required for this. The current latest version of ruby is 1.9.3-p194.
For windows download the http://rubyinstaller.org/
For OSX download http://unfiniti.com/software/mac/jewelrybox/
For linux most users should know how to for their own distributions.
We will be using the following GEMs and they MUST BE installed ahead of time so you can be ahead of the game and safe in the event that the Internet isn’t accommodating.
bson (1.6.4)
bson_ext (1.6.4)
haml (3.1.4)
mongo (1.6.4)
rack (1.4.1)
rack-protection (1.2.0)
rack shotgun (0.9)
sinatra (1.3.2)
tilt (1.3.3)
Prior ruby experience isn’t required for this. We will NOT be using rails for this app.
The document introduces a workshop on big data tools and MongoDB, discusses how MediaGlu uses big data for advertising by tracking user paths across different channels, and outlines an agenda covering MongoDB fundamentals, running MongoDB, and labs on shell commands, aggregation, replication, and sharding.
The document discusses MongoDB and Spring Data integration. It provides examples of creating, querying, and commenting on documents using Spring Data and MongoDB. It also covers topics like replication, sharding, and eventual consistency in MongoDB.
MongoDB + Java - Everything you need to know Norberto Leite
Learn everything you need to know to get started building a MongoDB-based app in Java. We'll explore the relationship between MongoDB and various languages on the Java Virtual Machine such as Java, Scala, and Clojure. From there, we'll examine the popular frameworks and integration points between MongoDB and the JVM including Spring Data and object-document mappers like Morphia.
MongoDB is a document-oriented NoSQL database that stores data as JSON-like documents. It is schema-less, scales easily, supports dynamic queries on documents, and stores data in BSON format. MongoDB is good for high write loads, high availability, large and changing datasets. Installation is simple, and it supports replication and sharding for availability and scaling. Data can be embedded or referenced between documents. Indexes and text search are supported. Programming involves JavaScript and MongoDB methods.
An Evening with MongoDB - Orlando: Welcome and KeynoteMongoDB
This document provides an overview of MongoDB and introduces some key concepts. It discusses MongoDB's document-oriented data model and how it differs from relational databases. It also covers features like dynamic schemas, ad-hoc querying, secondary indexing, replication, sharding, and new features in MongoDB version 2.2 like concurrency improvements, tag-aware sharding, and TTL collections.
The document discusses MongoDB, a document-oriented, schema-free database that is built for performance and scalability. It provides examples of inserting, querying, and updating documents using operators. It also lists MongoDB tools like MongoMapper and Mongoid for Ruby on Rails and recommends ways to get started with MongoDB including trying it in a browser or shell and following blogs and presentations.
This document provides an overview and introduction to MongoDB. It discusses what MongoDB is, its features such as being schemaless and document-oriented, and how to install MongoDB. It also covers JSON and BSON formats and compares MongoDB to traditional RDBMS systems. The document recommends MongoDB for non-transactional applications and warns against using it for highly transactional or SQL-required problems.
This document summarizes a presentation about MongoDB given by Sean Laurent of StudyBlue, Inc. It introduces MongoDB and its features, including its document-oriented data model, flexible schemas, querying and updating capabilities, indexing, drivers, replication and sharding for scalability. Useful MongoDB tools are also discussed like the mongo shell, mongostat, mongotop and MMS monitoring. The document concludes with MongoDB's strengths like horizontal scaling and rapidly evolving schemas, and weaknesses like not being a drop-in replacement for SQL and limitations around transactions.
Schema design with MongoDB (Dwight Merriman)MongoSF
This document discusses schema design considerations for MongoDB, a document-oriented database. It recommends embedding related data rather than linking when possible to facilitate queries and atomicity. It also discusses using compare-and-swap operations to update documents atomically. Indexes should be used to make queries fast. Collections may need to be sharded, requiring the shard key to be chosen carefully. Multiple collections can model more complex data when natural.
This document provides an overview of MongoDB, including what it is, its key features of high performance, high availability, and automatic scaling. It discusses MongoDB's use of embedded documents and references to represent relationships between data. The document compares MongoDB to relational databases, noting MongoDB does not require data normalization. It provides examples of how data can be embedded or referenced in MongoDB and when each approach is best.
This document provides an introduction to MongoDB, including when to use and not use MongoDB, features of MongoDB like document structure, indexing, replication, sharding, and architecture. It outlines the basic MongoDB scheme including databases, collections, and documents. It describes concepts like replication, auto-sharding, and the logical and physical architecture of MongoDB. Finally, it provides steps for initial sharding configuration and backup recommendations.
Christian Kvalheim gave an introduction to NoSQL and MongoDB. Some key points:
1) MongoDB is a scalable, high-performance, open source NoSQL database that uses a document-oriented model.
2) It supports indexing, replication, auto-sharding for horizontal scaling, and querying.
3) Documents are stored in JSON-like records which can contain various data types including nested objects and arrays.
The document discusses using the MongoDB shell for debugging, testing, and administration tasks. It notes some limitations of using JavaScript in the shell, such as number and date handling. It provides examples of common shell commands like insert, update, remove, loading scripts, running commands, and profiling. Useful shell functions are also demonstrated like printjson and forEach. The document concludes by showing how to print indexes, find the largest document, use cursors, define aliases, and work with DBRefs.
MongoDB is an open-source, document-oriented database that provides flexible schemas, horizontal scaling, and high performance. It stores data as JSON-like documents with dynamic schemas, making the integration of data easier for developers. MongoDB can be scaled horizontally and supports replication and load balancing for high availability.
NoSQL - MongoDB. Agility, scalability, performance. I am going to talk about the basis of NoSQL and MongoDB. Why some projects requires RDBMs and another NoSQL databases? What are the pros and cons to use NoSQL vs. SQL? How data are stored and transefed in MongoDB? What query language is used? How MongoDB supports high availability and automatic failover with the help of the replication? What is sharding and how it helps to support scalability?. The newest level of the concurrency - collection-level and document-level.
MongoDB is a non-SQL document-oriented database where data is stored in BSON format. It is well-suited for write-intensive applications, geo-spatial queries, flexible schemas where requirements may change, and scaling through sharding. Key advantages include very fast writes, no need for migrations when changing schemas, and built-in support for features like sharding, geospatial indexing, and logging to capped collections.
Ryan Angilly is a senior developer at MyPunchbowl.com who has an electrical engineering background but has primarily built web applications using Ruby and Rails with SQL databases. He had no experience with NoSQL or MongoDB until September 2009 when MyPunchbowl decided to explore using it to handle their large datasets from millions of users, events, invites and vendors. He aims to provide a beginner's perspective on transitioning from SQL to MongoDB.
Trisha Gee explores the deeper relationship between the MongoDB database and various languages on the Java Virtual Machine such as Java, Scala, Clojure, JRuby and Python as well as the challenges posted getting MongoDB to play nice with these tools and their syntax. Also examined will be frameworks and integration points popular between MongoDB and the JVM such as Spring Data, Morphia and Lift’s MongoDB-Record component.
This document provides an overview of building an app using Perl and MongoDB. It discusses what MongoDB is and its key features. It describes the modules needed from CPAN to interface with MongoDB from Perl. It outlines the structure of a sample "Library" app to demonstrate CRUD operations on books, authors, and other entities. The document walks through building this app and interacting with MongoDB documents and collections. It provides resources to learn more about MongoDB and the MongoDB Perl API.
This document provides an overview and introduction to MongoDB, including:
- MongoDB is a non-relational, document-oriented database with dynamic schemas and stores data in JSON-like documents rather than tables.
- It is well suited for prototyping, quick development refactoring, non-relational data, log data and metadata. Related data and needing joins may not be the best use case.
- Installation and configuration process varies by operating system but involves downloading packages and creating a data directory with correct permissions.
- The MongoDB command line interface provides commands to view and manage databases, collections, documents and perform basic operations like create, read, update and delete.
Jumpstart your day with an introduction to MongoDB by building a simple web app with React, Atlas, and Stitch. First, we will cover the foundations of schema design, security, queries and indexing. Then we'll partially refactor an application using the MERN stack to a serverless application using MongoDB Stitch.
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.
Chad Tindel's presentation covered schema design considerations for MongoDB including working with documents, evolving schemas over time, queries and indexes, and common data modeling patterns. Some key points included embedding data for performance, using references when growth is unbounded, and modeling one-to-many relationships by either embedding the related data or storing foreign keys. The presentation provided examples of modeling patrons, books, publishers, and other data to demonstrate schema patterns for trees, inheritance, and other common relationships.
MongoDB is a document-oriented NoSQL database that is used by many large companies. It stores data in flexible JSON-like documents within collections, allows for unrestricted indexing of fields, and scales horizontally through replication and sharding. Documents can have different fields and are composed of key-value pairs that can be added or removed freely.
The elephant in the room mongo db + hadoopiammutex
The document discusses integrating MongoDB and Hadoop to enable running MapReduce jobs on MongoDB data using Hadoop. It describes how Hadoop can address some limitations of MongoDB's built-in MapReduce functionality, like limited language support and scalability. It then provides an example of running a word count MapReduce job on MongoDB data using the Java API, with the job reading from and writing to MongoDB collections.
This document provides an overview of MongoDB, Java, and Spring Data. It discusses how MongoDB is a document-oriented NoSQL database that uses JSON-like documents with dynamic schemas. It describes how the Java driver can be used to interact with MongoDB to perform CRUD operations. It also explains how Spring Data provides an abstraction layer over the Java driver and allows for object mapping and repository-based queries to MongoDB.
This document provides an overview of a MongoDB workshop. It includes an agenda with topics like an overview of databases, what is MongoDB, MongoDB commands, sharding and replication in MongoDB, and a demo. The workshop is hosted by Vivian at ThoughtWorks for the audience of NYC Open Data and will be presented by Kannan Sankaran and Roman Kubiak.
It is a NYC Open Data Meetup event. All credits went to Kannan and Roman.
Event link: http://www.meetup.com/NYC-Open-Data/events/141123082/ Blog Post: http://www.nycopendata.com/2014/02/11/mongodb/
The document provides an agenda and overview for a presentation on schema design in MongoDB. Some key points include:
- Discussing common patterns for modeling one-to-one, one-to-many, and many-to-many relationships
- Examples of embedding vs. linking related data
- Considerations for schema design like data access patterns and growth
- Modeling trees and hierarchies using parent/child references
The presentation covers modeling different types of relationships and navigating tradeoffs in schema design.
MongoDB is a document-oriented, horizontally scalable database. It uses dynamic schemas and stores data as JSON-like documents with optional schemas. MongoDB can be scaled out across multiple servers for high availability and large data volumes. Key features include replication, sharding, index types, atomic operations, embedded documents, and MapReduce.
This talk will introduce the philosophy and features of the open source, NoSQL MongoDB. We’ll discuss the benefits of the document-based data model that MongoDB offers by walking through how one can build a simple app to store books. We’ll cover inserting, updating, and querying the database of books.
Shivam Singhal - Senior Engineer at Atlogys delivers a highly informative, practical and hands-on workshop cum talk on Mongo DB and how it can be & should be used in making real world web applications.
Part of the Atlogys Academy series, this talk covers the fundamentals of this noSQL technology and then goes on to show many practical examples on the command line as well. A must watch for anyone working with Mongo DB.
Agenda:
MongoDB Overview/History
Workshop
1. How to perform operations to MongoDB – Workshop
2. Using MongoDB in your Java application
Advance usage of MongoDB
1. Performance measurement comparison – real life use cases
3. Doing Cluster setup
4. Cons of MongoDB with other document oriented DB
5. Map-reduce/ Aggregation overview
Workshop prerequisite
1. All participants must bring their laptops.
2. https://github.com/geek007/mongdb-examples
3. Software prerequisite
a. Java version 1.6+
b. Your favorite IDE, Preferred http://www.jetbrains.com/idea/download/
c. MongoDB server version – 2.6.3 (http://www.mongodb.org/downloads - 64 bit version)
d. Participants can install MongoDB client – http://robomongo.org/
About Speaker:
Akbar Gadhiya is working with Ishi Systems as Programmer Analyst. Previously he worked with PMC, Baroda and HCL Technologies.
MongoDB is an open-source, document-oriented database that provides high performance and horizontal scalability. It uses a document-model where data is organized in flexible, JSON-like documents rather than rigidly defined rows and tables. Documents can contain multiple types of nested objects and arrays. MongoDB is best suited for applications that need to store large amounts of unstructured or semi-structured data and benefit from horizontal scalability and high performance.
This document provides an introduction to MongoDB, including what it is, why it may be used, and how its data model works. Some key points:
- MongoDB is a non-relational database that stores data in flexible, JSON-like documents rather than fixed schema tables.
- It offers advantages like dynamic schemas, embedding of related data, and fast performance at large scales.
- Data is organized into collections of documents, which can contain sub-documents to represent one-to-many relationships without joins.
- Queries use JSON-like syntax to search for patterns in documents, and indexes can improve performance.
Similar to Mongo DB on the JVM - Brendan McAdams (20)
Everything I know about software in spaghetti bolognese: managing complexityJAX London
None of of us enjoy spaghetti code, much less spaghetti builds, spaghetti tests, or spaghetti classpaths. Some days software engineering seems like the struggle against spaghetti - modern projects often become a large and complex tangle of source code and resources, and the runtime interactions are even worse! This means many projects are hard to navigate, difficult to extend and problematic to deploy/run. You only have to look at the OpenJDK itself to see the problems it faces in trying to have a smaller deployment and runtime footprint! Jigsaw was to be the inbuilt solution for the OpenJDK, extending beyond the JVM itself to help applications with their modularisation story (i.e. Jigsaw or OSGi). Sadly, Jigsaw is not going to make it for Java 8, so developers are left with only a few tooling choices in order to help them. However, tooling is only part of the answer in managing the complexity. What really matters in avoiding a noodly mess is the layout of your source code and resources, clear contracts, and how you think about the dependencies your code has at runtime. Dr Holly Cummins and Martijn Verburg will take you through some of the practical design decisions you can take to help modularise your application properly, independent of tooling. Time permitting they'll then showcase some of tooling support that OSGi can bring to the table as the premier modularity system for Java today.
Devops with the S for Sharing - Patrick DeboisJAX London
Devops means many things to many people. Even without a clear definition people instantly understand the problem space, while the solution space is much more complex and layered. In this talk on devops, different fields and practices will be presented, including how Devops is related to Agile and Lean, and the central roles that infrastructure as code, metrics and monitoring have. Many devops talks relate to the CAMS acronym : Culture, Automation, Measuring and Sharing. The S for Sharing is usually taken for granted and does not get much explanation, but in this talk it will be right in the centre. Without Sharing there is no Devops and successful adoption is impossible.
Busy Developer's Guide to Windows 8 HTML/JavaScript AppsJAX London
With the upcoming release of Windows 8, Microsoft decided to bring HTML+Javascript into the world of Windows-platform application development as a first-class citizen. But make no mistake, this isn’t an attempt to somehow subvert Web developers—it’s more about enabling Web developers to leverage those skills in building “native” Windows applications running on the Windows 8 laptops, desktops, and slates. In this presentation, we’ll go over the basics of building a Windows 8 app using HTML and JavaScript, including a brief overview of what’s possible—and what’s not—for the Web developer seeking to “go native” on Windows.
It's code but not as we know: Infrastructure as Code - Patrick DeboisJAX London
Configuration Management systems like CFEngine, Puppet and Chef, are often adopted as part of devops toolchains. It promises us infrastructure as code a concept that leads to 'Agile' infrastructure: In this session I'd like to give: - a brief explanation of the concept and why it's useful - an overview about the similarities this has with regular code - concepts such as TDD, BDD how well can they be translated - how it fits in with continuous Integration for systems Besides the concept translation I will add links to existing tools and project that working and evolving in the space. And finally, is it really the same? Does a coding background help you? Where do the tools/concepts need improvement? After this session I'm sure you'll be ready to give it a spin and explore more and possibly share some ideas back.
Locks? We Don't Need No Stinkin' Locks - Michael BarkerJAX London
Embrace the dark side. As a developer you'll often be advised that writing concurrent code should be the purview of the genius coders alone. In this talk Michael Barker will discard that notion into the cesspits of logic and reason and attempt to present on the less understood area of non-blocking concurrency, i.e. concurrency without locks. We'll look the modern Intel CPU architecture, why we need a memory model, the performance costs of various non-blocking constructs and delve into the implementation details of the latest version of the Disruptor to see how non-blocking concurrency can be applied to build high performance data structures.
Worse is better, for better or for worse - Kevlin HenneyJAX London
Over two decades ago, Richard P Gabriel proposed the thesis of "Worse Is Better" to explain why some things that are designed to be pure and perfect are eclipsed by solutions that are seemingly limited and incomplete. This is not simply the observation that things that should be better are not, but that some solutions that were not designed to be the best were nonetheless effective and were the better option. We find many examples of this in software development, some more provocative and surprising than others. In this talk we revisit the original premise and question in the context of software architecture.
Java performance: What's the big deal? - Trisha GeeJAX London
It seems that everywhere you look these days people are needing to work on high performance/low latency applications. If they're not already working on them, then they want to be. But what do you really need to know when you're working on performance-sensitive systems? Where do you get started? In this session, Trisha outlines things you need to consider when thinking about performance, covers some of the frequently-asked questions, and notes the pitfalls and common traps that developers fall into.
This document provides an overview of Clojure and why one may want to try it. Some key points include:
- Clojure is a functional programming language that runs on the JVM and allows easy interoperability with Java.
- It has a very small and elegant syntax based on Lisp with sensible macro names and prefix notation.
- Clojure encourages pure functional programming and the use of immutable data structures, while providing tools like Software Transactional Memory to allow safe mutable state changes.
- Its focus on functions as first-class citizens and referential transparency can provide benefits for writing parallel and concurrent code more easily compared to other languages.
HTML alchemy: the secrets of mixing JavaScript and Java EE - Matthias WessendorfJAX London
This document summarizes a presentation about developing mobile applications using HTML5, REST, and JavaScript frameworks. It discusses using JAX-RS to create RESTful endpoints in Java EE that return JSON/XML, and consuming those endpoints from HTML5 web apps or hybrid mobile apps built with Apache Cordova. It also introduces the AeroGear framework for extending Java EE functionality to mobile clients and facilitating mobile development. Demos are provided of AeroGear.js, Backbone.js, and the AeroGear-iOS library. The roadmap includes adding support for WebSockets, data syncing, and push notifications across the AeroGear projects.
This presentation introduces the key innovations that Play 2 brings to web application development in Java and Scala. The Play framework has brought high-productivity web development to Java with three innovations that changed the rules on Java EE: Java class and template save-and-reload that just works, a simplified stateless architecture that enables cloud deployment, and superior ease-of-use. Following Play's rapidly-growing popularity, Play 2.0 was released in March 2012 with innovations that are not just new in the Java world: type-safe view templates and HTTP routing, compile-time checking for static resources, and native support for both Java and Scala. Type safety matters. After dynamically-typed programming languages such as PHP and Ruby set the standard for high-productivity web development, Play built on their advantages and has created a type-safe web development framework with extensive compile-time checking. This is essential for applications that will scale to tens of thousands of lines of code, with hundreds of view templates. Meanwhile, Play avoids the architectural-complexity that is promoted by Java EE-based approaches. The result is that Play 2 first enables rapid initial application development and then Play 2 helps you build big, serious and scalable web applications.
Complexity theory and software development : Tim BerglundJAX London
Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines. Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet—perhaps the most valuable piece of computing infrastructure of the present day—may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we'll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.
Why FLOSS is a Java developer's best friend: Dave GruberJAX London
The explosion of new open source projects is changing the game for today’s Java developers. With literally hundreds of thousands of FOSS projects underway, the opportunity to leverage open source to deliver “the trifecta” (faster/better/cheaper) has never been better. In this session we will explore tools and resources that can help you navigate the vast world of open source projects, in addition to sharing tips and tricks that will help you narrow the field so you can quickly get to the right projects for your next application.
Scalable systems make us face challenges like concurrency, distribution, fault tolerance, elasticity, etc. Akka not only steps up to meet these, but it makes writing scalable software particularly easy. We will demo Akka's most important tool, the actor model, using a vivid example and live coding.
Alternative databases continue to establish their role in the technology stack of the future—and for many, the technology stack of the present. Making mature engineering decisions about when to adopt new products is not easy, and requires that we learn about them both from an abstract perspective and from a very concrete one as well. If you are going to recommend a NoSQL database for a new project, you're going to have to look at code. In this talk, we'll examine three important contenders in the NoSQL space: Cassandra, MongoDB, and Neo4J. We'll review their data models, scaling paradigms, and query idioms. Most importantly, we'll work through the exercise of modeling a real-world problem with each database, and look at the code and queries we'd use to implement real product features. Come to this session for a thorough and thoroughly practical smackdown between three important NoSQL products.
Closures, the next "Big Thing" in Java: Russel WinderJAX London
Java 8 will bring lambda function and closures to the Java-verse. These tools will revolutionize programming using Java, leading to shorter more declarative code. But how can we prepare ourselves for this? A number of JVM-based languages already have support for lambda functions and closures: dynamically-typed languages like Groovy, and statically-typed languages like Scala and Kotlin. Can looking at examples of how to solve problems in these languages teach us how to do things in Java 8? Yes. Of course the observation of how programming changes may get people to start using Groovy, Scala, Kotlin, etc. instead of Java. The critical thing here is that we can realize the revolution in an evolutionary way. The JVM allows for all of these languages to work together, we can program bits in Java, bits in Groovy, bits in Scala, etc. So we can evolve extant systems by rewriting bits a little at a time. In this session we will look at these issues and a collection of examples to try and ascertain what the idioms might be in a post-Java 8 world.
Java and the machine - Martijn Verburg and Kirk PepperdineJAX London
In Terminator 3 - Rise of the Machines, bare metal comes back to haunt humanity, ruthlessly crushing all resistance. This keynote is here to warn you that the same thing is happening to Java and the JVM! Java was designed in a world where there were a wide range of hardware platforms to support. Its premise of Write Once Run Anywhere (WORA) proved to be one of the compelling reasons behind Java's dominance (even if the reality didn't quite meet the marketing hype). However, this WORA property means that Java and the JVM struggled to utilise specialist hardware and operating system features that could make a massive difference in the performance of your application. This problem has recently gotten much, much worse. Due to the rise of multi-core processors, massive increases in main memory and enhancements to other major hardware components (e.g. SSD), the JVM is now distant from utilising that hardware, causing some major performance and scalability issues! Kirk Pepperdine and Martijn Verburg will take you through the complexities of where Java meets the machine and loses. They'll give up some of their hard-won insights on how to work around these issues so that you can plan to avoid termination, unlike some of the poor souls that ran into the T-800...
New opportunities for connected data - Ian RobinsonJAX London
The document discusses new opportunities for connected data using graph databases. It covers topics like data complexity, graph databases features and benefits, querying graph data, and use cases. The key points are that graph databases are well-suited for domains with dense connections and semi-structured data, allow for easy data model evolution, and enable fast querying of relationships between millions of entities.
The family of HTML5 technologies has pushed the pendulum away from rich client technologies and towards ever more capable web clients running in today's browsers. In particular, WebSockets brings new opportunities for efficient peer to peer communication, providing the basis for a new generation of interactive and 'live' web applications. This session examines the efforts underway to support WebSockets in the Java programming model using JSR 356, from its base level integration in the Java Servlet and Java EE containers, to a new easy to use API and toolset that is destined to become a part of the standard Java Platform.
The Big Data Con: Why Big Data is a Problem, not a Solution - Ian PloskerJAX London
"Big Data" is a commonly brandished term, but rarely does anyone provide a clear definition of it. If we stop to define Big Data, we find that at its core, it is about an inability to meet the challenges of information storage and access in a world where data is generated by the petabyte. As an alternative exists the concept of Critical Data, data that generates value for businesses, whose unavailability costs money or even lives. This is the data which has already been identified and understood to be at the core of a business. Together, we will gain a deeper understanding of how to gather, store, and access this business critical information.
Bluffers guide to elitist jargon - Martijn Verburg, Richard Warburton, James ...JAX London
Have you always secretly wondered what the heck 'monads' are? How about 'Tail-call recursion?' or 'monomorphic dispatch'? If this sort of terminology has ever left you with self-doubts or seething with anger because someone is confusing you with elitist terminology, then this is the talk for you! Dr Richard Warburton and the Diabolical Developer + James Gough will take a humorous look at the wide range of incomprehensible terminology in our industry today. They'll cover the concepts behind the jargon with simple examples and some practical tips on how to blend the terminology into your day to day technical conversations without scaring everyone off. At the end of the talk you'll be ready to battle it out on tough mailing lists (Scala!) and have a new appreciation for some of the academic principles behind our craft. Oh and as for monads? Well they're just like burritos, except they're not...
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Introducing Milvus Lite: Easy-to-Install, Easy-to-Use vector database for you...Zilliz
Join us to introduce Milvus Lite, a vector database that can run on notebooks and laptops, share the same API with Milvus, and integrate with every popular GenAI framework. This webinar is perfect for developers seeking easy-to-use, well-integrated vector databases for their GenAI apps.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
3. Let’s Face It ...
SQL Sucks.
For some problems at least.
Tuesday, October 16, 12
4. Stuffing an object graph into a relational model is
like fitting a square peg into a round hole.
Tuesday, October 16, 12
5. Stuffing an object graph into a relational model is
like fitting a square peg into a round hole.
Databases should simplify application development - they
should present a model that fits naturally with our code
Tuesday, October 16, 12
16. MongoDB as a Database
• Document Oriented Data
Tuesday, October 16, 12
17. MongoDB as a Database
• Document Oriented Data
• Instead of flat row structures, “document oriented”
data (similar to JSON)
Tuesday, October 16, 12
18. MongoDB as a Database
• Document Oriented Data
• Instead of flat row structures, “document oriented”
data (similar to JSON)
• Rich: Embed other documents and arrays as values
Tuesday, October 16, 12
19. Rich Documents Represent MongoDB Data
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“publisher”: “The Pragmatic Programmers, LLC”,
}
Tuesday, October 16, 12
20. Rich Documents Represent MongoDB Data
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“publisher”: “The Pragmatic Programmers, LLC”,
}
Like JSON , MongoDB Documents are made up of key and
value pairs.
Tuesday, October 16, 12
26. Querying with MongoDB
• Querying in MongoDB is similar to a ‘query by example’
interface
Tuesday, October 16, 12
27. Querying with MongoDB
• Querying in MongoDB is similar to a ‘query by example’
interface
Tuesday, October 16, 12
28. Querying with MongoDB
• Querying in MongoDB is similar to a ‘query by example’
interface
• Finding items by exact match via “key” = “value”
Tuesday, October 16, 12
29. Querying with MongoDB
• Querying in MongoDB is similar to a ‘query by example’
interface
• Finding items by exact match via “key” = “value”
• Built-in Query Expressions for more advanced
statements
Tuesday, October 16, 12
30. Querying With MongoDB
> db.books.find({“author”: “Joe Armstrong”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
}
Tuesday, October 16, 12
31. Querying With MongoDB
> db.books.find({“author”: “Joe Armstrong”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
}
Basic queries consist of “key” = “value”
Tuesday, October 16, 12
32. Querying With MongoDB
> db.books.find({“price.currency”: “USD”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
}
Tuesday, October 16, 12
33. Querying With MongoDB
> db.books.find({“price.currency”: “USD”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
} Embedded docs can be accessed by
“key.subkey” = “value”
Tuesday, October 16, 12
34. Querying With MongoDB
> db.books.find({“tags”: “multicore”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
}
Tuesday, October 16, 12
35. Querying With MongoDB
> db.books.find({“tags”: “multicore”})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
} Embedded arrays can be accessed by
matching just a single value from the array
Tuesday, October 16, 12
36. Querying With MongoDB
> db.books.find({“price.discount”: {$lt: 25.00}})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
}
Tuesday, October 16, 12
37. Querying With MongoDB
> db.books.find({“price.discount”: {$lt: 25.00}})
{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“publisher”: “The Pragmatic Programmers, LLC”,
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
} Finally, MongoDB provides a set of query expressions for
concepts such as greater than, less than, etc.
Tuesday, October 16, 12
39. MongoDB as a Database
• Scalability
Tuesday, October 16, 12
40. MongoDB as a Database
• Scalability
• Database should grow and scale with our application
Tuesday, October 16, 12
41. MongoDB as a Database
• Scalability
• Database should grow and scale with our application
• Replica Sets: Robust, modernized Replication Model with
automatic failover
Tuesday, October 16, 12
42. MongoDB as a Database
• Scalability
• Database should grow and scale with our application
• Replica Sets: Robust, modernized Replication Model with
automatic failover
• Sharding: n-scalable horizontal partitioning with automatic
management
Tuesday, October 16, 12
44. MongoDB on the JVM
• MongoDB has strong, wide support on the JVM
Tuesday, October 16, 12
45. MongoDB on the JVM
• MongoDB has strong, wide support on the JVM
• Java
Tuesday, October 16, 12
46. MongoDB on the JVM
• MongoDB has strong, wide support on the JVM
• Java
• Scala
Tuesday, October 16, 12
47. MongoDB on the JVM
• MongoDB has strong, wide support on the JVM
• Java
• Scala
• Hadoop
Tuesday, October 16, 12
48. MongoDB on the JVM
• MongoDB has strong, wide support on the JVM
• Java
• Scala
• Hadoop
• Also, fantastic work occurring in Clojure community
(see Monger - http://clojuremongodb.info/ )
Tuesday, October 16, 12
53. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
Tuesday, October 16, 12
54. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
• Morphia
Tuesday, October 16, 12
55. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
• Morphia
• Map domain objects to MongoDB with JPA-like
annotations
Tuesday, October 16, 12
56. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
• Morphia
• Map domain objects to MongoDB with JPA-like
annotations
• Spring Data
Tuesday, October 16, 12
57. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
• Morphia
• Map domain objects to MongoDB with JPA-like
annotations
• Spring Data
• Spring ODM for many NoSQL databases, supports
MongoDB
Tuesday, October 16, 12
58. MongoDB + Java
• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)
• Manipulate MongoDB Docs as Map-like structures
• “Object Document Mapping” (like Hibernate, but less
painful)
• Morphia
• Map domain objects to MongoDB with JPA-like
annotations
• Spring Data
• Spring ODM for many NoSQL databases, supports
MongoDB
• GA Release announced today
Tuesday, October 16, 12
60. Core MongoDB + Java
The Mongo class represents a connection pool
com.mongodb.Mongo m = new Mongo();
Tuesday, October 16, 12
61. Core MongoDB + Java
The Mongo class represents a connection pool
com.mongodb.Mongo m = new Mongo();
The DB class represents a Database context
com.mongodb.DB db = m.getDB( "bookstore" );
Tuesday, October 16, 12
62. Core MongoDB + Java
The Mongo class represents a connection pool
com.mongodb.Mongo m = new Mongo();
The DB class represents a Database context
com.mongodb.DB db = m.getDB( "bookstore" );
The DBCollection class represents a Collection
(Mongo’s version of a table) handle
com.mongodb.DBCollection coll = db.getCollection( "books" );
Tuesday, October 16, 12
64. Core MongoDB + Java
Documents are represented by DBObject
com.mongodb.DBObject q = new BasicDBObject();
q.put( “tag”, “scala” );
q.put( “price”, new BasicDBObject( “$lt”, 40.00 ) );
Tuesday, October 16, 12
65. Core MongoDB + Java
Documents are represented by DBObject
com.mongodb.DBObject q = new BasicDBObject();
q.put( “tag”, “scala” );
q.put( “price”, new BasicDBObject( “$lt”, 40.00 ) );
Queries return a DBCursor, which is both
Iterator<DBObject> and Iterable<DBObject>
for ( DBObject doc : coll.find( q ) ) {
// ...
}
Tuesday, October 16, 12
67. Core MongoDB + Java
There is also a QueryBuilder helper class for
querying
DBObject q = QueryBuilder.start( “price” ).lessThan( 40.00 ).
and( “tag” ).is( “scala” ).get();
Tuesday, October 16, 12
68. Core MongoDB + Java
There is also a QueryBuilder helper class for
querying
DBObject q = QueryBuilder.start( “price” ).lessThan( 40.00 ).
and( “tag” ).is( “scala” ).get();
If you don’t fancy doing everything by hand, you
can use tools like Morphia to map domain objects
automatically...
Tuesday, October 16, 12
70. Object Mapping Java via Morphia
Morphia uses JPA-like Annotations to mark up
domain objects for MongoDB persistence
@Entity("books") // Book classes persist to / from “books”
class Book {}
Tuesday, October 16, 12
71. Object Mapping Java via Morphia
Morphia uses JPA-like Annotations to mark up
domain objects for MongoDB persistence
@Entity("books") // Book classes persist to / from “books”
class Book {}
Any field can be tagged as the primary key via the
@Id annotation
@Id private ObjectId id;
Tuesday, October 16, 12
72. Object Mapping Java via Morphia
Morphia uses JPA-like Annotations to mark up
domain objects for MongoDB persistence
@Entity("books") // Book classes persist to / from “books”
class Book {}
Any field can be tagged as the primary key via the
@Id annotation
@Id private ObjectId id;
List fields are automatically persisted as
MongoDB arrays
private List<String> tags = new ArrayList<String>();
Tuesday, October 16, 12
74. Object Mapping Java via Morphia
Complex sub-objects can be marked to either
“embed” or “reference” automatically
/**
* Could also use "reference", which are stored to
* their own collection and loaded automatically
*
* Morphia uses the field name for where to store the value,
*/
@Embedded private Price price;
Tuesday, October 16, 12
75. Object Mapping Java via Morphia
Complex sub-objects can be marked to either
“embed” or “reference” automatically
/**
* Could also use "reference", which are stored to
* their own collection and loaded automatically
*
* Morphia uses the field name for where to store the value,
*/
@Embedded private Price price;
It’s trivial to name a field one thing in MongoDB
and another in our Morphia model
/**
* Can rename a field for how stored in MongoDB
*/
@Property("publicationYear") private int year;
Tuesday, October 16, 12
79. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
Tuesday, October 16, 12
80. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
Tuesday, October 16, 12
81. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
Tuesday, October 16, 12
82. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight
Tuesday, October 16, 12
83. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight
• Lift - Popular Scala web framework includes a MongoDB ODM
layer based on the ActiveRecord pattern
Tuesday, October 16, 12
84. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight
• Lift - Popular Scala web framework includes a MongoDB ODM
layer based on the ActiveRecord pattern
•Next-Generation Drivers (async focus) [Pure rewrites of driver]
Tuesday, October 16, 12
85. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight
• Lift - Popular Scala web framework includes a MongoDB ODM
layer based on the ActiveRecord pattern
•Next-Generation Drivers (async focus) [Pure rewrites of driver]
• Hammersmith - my pet project, Netty + Akka.IO interfaces, strongly
functional and callback based
Tuesday, October 16, 12
86. MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)
•Wraps the Java driver, provides strong Scala API
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight
• Lift - Popular Scala web framework includes a MongoDB ODM
layer based on the ActiveRecord pattern
•Next-Generation Drivers (async focus) [Pure rewrites of driver]
• Hammersmith - my pet project, Netty + Akka.IO interfaces, strongly
functional and callback based
• ReactiveMongo - from the amazing team @ Zenexity who brought us
the Play! Framework - new, but very promising
Tuesday, October 16, 12
90. Basic MongoDB + Scala via Casbah
Because it is a full Collection implementation,
construction Builder style is easy as well
val b = MongoDBObject.newBuilder
b += "foo" -> "bar"
b += "x" -> 5
b += "map" -> Map("spam" -> 8.2, "eggs" -> "bacon")
val dbObj = b.result
Tuesday, October 16, 12
91. Basic MongoDB + Scala via Casbah
Because it is a full Collection implementation,
construction Builder style is easy as well
val b = MongoDBObject.newBuilder
b += "foo" -> "bar"
b += "x" -> 5
b += "map" -> Map("spam" -> 8.2, "eggs" -> "bacon")
val dbObj = b.result
It’s even easy to start with a blank DBObject
val dbObj = MongoDBObject.empty
dbObj must beDBObject
dbObj must have size (0)
Tuesday, October 16, 12
93. Basic MongoDB + Scala via Casbah
While Casbah wraps the Java Driver for the
Mongo protocol, its API aims to be as Scala pure
as possible
val mongo: MongoCollection = MongoConnection()("bookstore")("books")
Tuesday, October 16, 12
94. Basic MongoDB + Scala via Casbah
While Casbah wraps the Java Driver for the
Mongo protocol, its API aims to be as Scala pure
as possible
val mongo: MongoCollection = MongoConnection()("bookstore")("books")
Casbah’s Cursors can easily be iterated in
standard Scala style
def findAll() = for ( book <- mongo.find() ) yield newBook(book)
findAll().foreach(b => println("<Book> " + b))
Tuesday, October 16, 12
96. Basic MongoDB + Scala via Casbah
Leveraging Scala’s great support for composable
DSLs, Casbah provides a Query DSL that feels
natural to a MongoDB user...
val q: DBObject = ("price" $lt 40.00) ++ ("tag" -> "scala")
Tuesday, October 16, 12
97. Basic MongoDB + Scala via Casbah
Leveraging Scala’s great support for composable
DSLs, Casbah provides a Query DSL that feels
natural to a MongoDB user...
val q: DBObject = ("price" $lt 40.00) ++ ("tag" -> "scala")
Like with Java, the Scala MongoDB Community
has created a few ways of mapping Objects as
well...
Tuesday, October 16, 12
99. Object Mapping in Scala via Lift
Lift uses an ActiveRecord style API for mapping
MongoDB + Scala
class Book private() extends BsonRecord[Book] with ObjectIdPk[Book]
{ }
Tuesday, October 16, 12
101. Object Mapping in Scala via Lift
Fields in Lift-Mongo are declared as objects
implementing a special typed trait.
object isbn extends StringField(this, 64)
Tuesday, October 16, 12
102. Object Mapping in Scala via Lift
Fields in Lift-Mongo are declared as objects
implementing a special typed trait.
object isbn extends StringField(this, 64)
Fields can be declared optional by overriding a
trait attribute
object edition extends StringField(this, 32) {
override def optional_? = true
}
Tuesday, October 16, 12
103. Object Mapping in Scala via Lift
Fields in Lift-Mongo are declared as objects
implementing a special typed trait.
object isbn extends StringField(this, 64)
Fields can be declared optional by overriding a
trait attribute
object edition extends StringField(this, 32) {
override def optional_? = true
}
And Lists can be automatically handled via a
MongoListField
object author extends MongoListField[Book, String](this)
Tuesday, October 16, 12
105. Object Mapping in Scala via Lift
Embedding objects represented by another entity
is easy as well
object price extends BsonRecordField(this, Price)
class Price private() extends BsonRecord[Price] {
// ...
object currency extends StringField(this, 3)
object discount extends DoubleField(this)
object msrp extends DoubleField(this)
}
Tuesday, October 16, 12
106. Object Mapping in Scala via Lift
Embedding objects represented by another entity
is easy as well
object price extends BsonRecordField(this, Price)
class Price private() extends BsonRecord[Price] {
// ...
object currency extends StringField(this, 3)
object discount extends DoubleField(this)
object msrp extends DoubleField(this)
}
To make working with Lift + MongoDB as easy as
possible, Foursquare has created a fantastic
Query DSL called Rogue:
https://github.com/foursquare/rogue
Tuesday, October 16, 12
108. Object Mapping in Scala via Lift
The downside to Lift is the need to use specially
structured objects. For those who want a less
formal API, Salat makes it easy...
Tuesday, October 16, 12
110. Object Mapping in Scala via Salat
Salat uses Scala’s case classes as the core of
their model (immutability is good!)
case class Book(id: ObjectId, author: Seq[Author], isbn: String,
price: Price, publicationYear: Int, tags: Seq[String],
title: String, publisher: String, edition: Option[String])
case class Author(name: String)
case class Price(currency: String, discount: Double, msrp: Double)
val authors = Seq( Author("Timothy Perrett") )
val price = Price("USD", 39.99, 39.99)
val tags = Seq("functional programming", "scala",
"web development", "lift", "#legendofklang")
val liftInAction = Book(new ObjectId, authors, "9781935182801",
price, 2011, tags,
"Lift in Action",
"Manning Publications Co.", Some("First"))
Tuesday, October 16, 12
112. Object Mapping in Scala via Salat
Persistence is made simple (through Scala
reflection) via the Grater object
/**
* The Salat Grater uses runtime Scala type reflection to
* generate a MongoDB Object.
*/
val dbo = grater[Book].asDBObject(liftInAction)
mongo.save(dbo)
Tuesday, October 16, 12
113. Object Mapping in Scala via Salat
Persistence is made simple (through Scala
reflection) via the Grater object
/**
* The Salat Grater uses runtime Scala type reflection to
* generate a MongoDB Object.
*/
val dbo = grater[Book].asDBObject(liftInAction)
mongo.save(dbo)
Some annotations are available to mark indexed
fields, etc but the core ideas in Salat are elegantly
simple
Tuesday, October 16, 12
117. MongoDB + Clojure
• Clojure + MongoDB
• “Core” MongoDB Driver (monger)
• Fairly new, similarities to Casbah, including a “native”
Query API
Tuesday, October 16, 12
118. MongoDB + Clojure
• Clojure + MongoDB
• “Core” MongoDB Driver (monger)
• Fairly new, similarities to Casbah, including a “native”
Query API
• Not officially supported
Tuesday, October 16, 12
119. MongoDB + Clojure
• Clojure + MongoDB
• “Core” MongoDB Driver (monger)
• Fairly new, similarities to Casbah, including a “native”
Query API
• Not officially supported
• The Monger team was nice enough to share some
snippets (my Clojure is a bit rusty)...
Tuesday, October 16, 12
121. Basic MongoDB + Clojure via Monger
Monger’s version of a Document is a simple
Clojure data structure
A Query API similar to Casbah’s is supported, and
very fluid
(monger.collection/find-maps collection {:price.discount {$lt 25.00}})
(monger.collection/update "things" { :_id oid } { $set { :weight 20.5 } })
Tuesday, October 16, 12
124. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
Tuesday, October 16, 12
125. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
Tuesday, October 16, 12
126. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
Tuesday, October 16, 12
127. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem
Tuesday, October 16, 12
128. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem
• Pig
Tuesday, October 16, 12
129. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem
• Pig
• Streaming
Tuesday, October 16, 12
130. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem
• Pig
• Streaming
• Hive & Scoobi (coming soon)
Tuesday, October 16, 12
131. MongoDB + Hadoop
• Hadoop + MongoDB
• Hadoop integration with MongoDB is one of my key projects
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem
• Pig
• Streaming
• Hive & Scoobi (coming soon)
• See http://api.mongodb.org/hadoop to learn more
Tuesday, October 16, 12
132. [Want to Know More About MongoDB?]
Free Online Classes, Starting in October!
http://education.10gen.com
[Docs]
http://mongodb.org
http://api.mongodb.org/
*Contact Me*
brendan@10gen.com
(twitter: @rit)
Tuesday, October 16, 12