Running MRuby in a Database - ArangoDB - RuPy 2012
3 likes1,857 views
The document discusses the integration of mruby, a lightweight Ruby implementation, within the ArangoDB NoSQL database framework. It highlights various technical aspects such as query language, script language use cases, comparisons between mruby and V8, and performance metrics. Ultimately, it posits that mruby can be a viable choice for scripting in databases, although using existing language drivers may be more practical depending on the situation.
1 of 19
Downloaded 12 times
![MRuby and LLVM
CASE(OP_SUB) {
/* A B C R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
int a = GETARG_A(i);
/* need to check if op is overridden */
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
{
mrb_int x, y, z;
x = mrb_fixnum(regs[a]);
y = mrb_fixnum(regs[a+1]);
z = x - y;
if (((x < 0) ^ (y < 0)) == 0 && (x < 0) != (z < 0)) {
/* integer overflow */
SET_FLT_VALUE(regs[a], (mrb_float)x - (mrb_float)y);
break;
}
SET_INT_VALUE(regs[a], z);
}
break;
Simply replacing OP codes by machine code already gives a factor of 2
www.arangodb.org (c) f.celler@triagens.de
Mittwoch, 14. November 12](https://image.slidesharecdn.com/rupy2012-v1-6-121114072313-phpapp02/85/Running-MRuby-in-a-Database-ArangoDB-RuPy-2012-17-320.jpg)
Ad
Recommended
Using MRuby in a database
Using MRuby in a databaseArangoDB Database The document discusses using the MRuby scripting language in databases. It provides an overview of NoSQL databases and the ArangoDB multi-model database. It then discusses use cases for scripting languages in databases for tasks like enriching results and computing values. The document compares MRuby and V8, noting MRuby is simpler to embed but slower. It argues MRuby may be an alternative embedding if performance is not critical or can be improved with LLVM compilation to machine code.
Hotcode 2013: Javascript in a database (Part 1)
Hotcode 2013: Javascript in a database (Part 1)ArangoDB Database This document discusses using JavaScript in databases. It describes how JavaScript can be used in the database for transactions defined as functions, graph traversal, and having no backend code, just an API. It provides examples of using JavaScript for transactions and graph traversal in ArangoDB.
Rupy2012 ArangoDB Workshop Part1
Rupy2012 ArangoDB Workshop Part1ArangoDB Database The document outlines an agenda for a workshop on ArangoDB and Ashikawa. The agenda includes introducing ArangoDB, installing it, performing CRUD operations, using the query language, and building a small example with the Ruby driver Ashikawa. It also provides information on importing data and performing queries on ArangoDB.
ArangoDB - Using JavaScript in the database
ArangoDB - Using JavaScript in the databaseArangoDB Database ArangoDB is an open-source NoSQL database that stores data as schema-free JSON documents organized in collections, allowing for flexible data modeling. It provides an HTTP REST API for querying, supports complex SQL-like queries, and enables the creation of server-side JavaScript actions to extend functionality. Additionally, ArangoDB supports referencing between documents and offers special functions for graph processing, making it useful for various application needs.
Is multi-model the future of NoSQL?
Is multi-model the future of NoSQL?Max Neunhöffer Max Neunhöffer presents on the future of NoSQL databases and argues multi-model databases will become the standard. He discusses different NoSQL data models like document stores, key-value stores, graph databases and column-oriented databases. He advocates the benefits of a polyglot persistence approach but notes the disadvantages of managing multiple databases. Max introduces ArangoDB as a multi-model database that supports documents, graphs and key-value in a single database to provide the benefits of polyglot persistence without the disadvantages. He provides examples of how ArangoDB has been used and outlines its features including queries, extensibility and horizontal scalability. Max predicts that in five years, the default approach will be to use a
ArangoDB
ArangoDBArangoDB Database The document summarizes the multi-purpose NoSQL database ArangoDB. It describes ArangoDB as a second generation database that is open source, free, and supports multiple data models including documents, graphs, and key-value. It highlights main features such as being extensible through JavaScript, having high performance, and being easy to use through its web interface and query language AQL.
Arango DB
Arango DBNexThoughts Technologies ArangoDB is a native multi-model NoSQL database developed by Triagens GmbH that supports key/value, document, and graph data models using the ArangoDB Query Language (AQL). The document outlines installation instructions, command line usage, integration with Spring, and key features such as ACID properties and simplified performance scaling. Additional resources and references for further exploration of ArangoDB are also provided.
FOXX - a Javascript application framework on top of ArangoDB
FOXX - a Javascript application framework on top of ArangoDBArangoDB Database This document discusses ArangoDB Foxx, a feature of ArangoDB that allows developers to define REST APIs and build single page web applications directly against the ArangoDB database using JavaScript. Foxx allows defining controllers with routes, parameterizing routes, generating documentation, and structuring models. It aims to provide a streamlined way for front-end developers to interface directly with the database without overhead typically involved in separating concerns across servers. The document outlines several Foxx features and capabilities including authentication, asset handling, and sharing code through a repository.
A Graph Database That Scales - ArangoDB 3.7 Release Webinar
A Graph Database That Scales - ArangoDB 3.7 Release WebinarArangoDB Database The document outlines the features of ArangoDB version 3.7, highlighting improvements in graph performance, ArangoSearch capabilities, cluster scalability, and security enhancements. Key updates include parallel graph traversals, fuzzy search options, incremental plan updates, and schema validation. The document also mentions the deprecation of the mmfiles storage engine and introduces ArangoDB Oasis for cloud deployment.
Multi-model databases and node.js
Multi-model databases and node.jsMax Neunhöffer The document discusses multi-model databases, highlighting the combination of document stores, graph databases, and key/value stores within a single database system. It emphasizes the advantages of polyglot persistence while addressing the challenges of managing multiple database systems. The proposed multi-model database supports various data models and provides a framework for extensibility and convenience in data management.
A Little SPARQL in your Analytics
A Little SPARQL in your AnalyticsDr. Neil Brittliff The document discusses Semantic Web technologies including RDF, SPARQL and ontologies. It provides:
1) An introduction to the Semantic Web vision of machines being able to understand and respond to complex requests based on meaning. This requires information to be semantically structured.
2) A brief overview of key concepts in RDF including triples, nodes, blank nodes, and predefined RDF structures like bags and lists.
3) An explanation of the SPARQL query language, which is similar to SQL but interrogates the Semantic Web. SPARQL clauses like SELECT, CONSTRUCT, DESCRIBE and ASK are covered.
4) A discussion of ontological representations including R
Comparison with storing data using NoSQL(CouchDB) and a relational database.
Comparison with storing data using NoSQL(CouchDB) and a relational database.eross77 The document provides an introduction to NoSQL, particularly focusing on CouchDB, which stores data in JSON documents and supports replication and accessibility through a REST API. It discusses various features and characteristics of NoSQL databases, including ease of deployment and the absence of a required schema. Additionally, it compares popular NoSQL document stores like MongoDB, CouchDB, Couchbase, and Redis, highlighting their unique attributes and use cases.
Visualize your graph database
Visualize your graph databaseMichael Hackstein Michael Hackstein discusses techniques to visualize and manage graph data using a web-based administration interface. The document highlights the technology stack including D3.js for rendering and ArangoDB for data storage and querying, while addressing challenges like graph size and readability. Various exploration methods and visual techniques such as vertex grouping and fish-eye distortion are also explored.
Small Overview of Skype Database Tools
Small Overview of Skype Database Toolselliando dias Skype uses PostgreSQL for over 100 database servers and 200 databases to support its online services. It partitions data across multiple databases for scalability and uses tools like pgBouncer, PL/Proxy, SkyTools, PgQ, and Londiste to connect, load balance, and replicate data between databases. This complex database architecture has allowed Skype to grow significantly while remaining easy to manage.
Solid pods and the future of the spatial web
Solid pods and the future of the spatial webKurt Cagle This document discusses Solid Pods and their potential role in the future of the spatial web. Solid Pods are small, deployable graph databases that follow the principles of the Solid project, including allowing individuals to own and have granular control over their data. Solid Pods address issues that limited the adoption of earlier semantic web efforts. They could store scene graphs, serve as data catalogs, support distributed ledgers, and more. As graph databases, Pods are well-suited to power spatial applications through capabilities like hosting knowledge graphs and serving as intermediate calculation nodes. Standards bodies are exploring how Spatial Web specifications could adopt and extend the Solid Pod architecture.
An introduction to Nosql
An introduction to Nosqlgreprep This document provides an introduction to NoSQL databases. It describes NoSQL as non-relational, distributed, open-source databases that are horizontally scalable with no predefined schema. It lists the main types of NoSQL databases as document stores, graph stores, key-value stores, and wide-column stores. The document gives MongoDB as an example of a document database and explains that sharding allows horizontal scaling by storing data records across multiple machines.
OrientDB: Unlock the Value of Document Data Relationships
OrientDB: Unlock the Value of Document Data RelationshipsFabrizio Fortino The document discusses OrientDB, a multi-model database that integrates document and graph database functionalities. It emphasizes the importance of considering non-relational data storage options in the context of increasing amounts of unstructured data and the complexity of data relationships. The presentation outlines the features, applications, and advantages of using OrientDB for managing and querying complex data interactions efficiently.
PostgreSQL - Object Relational Database
PostgreSQL - Object Relational DatabaseMubashar Iqbal Mubashar Iqbal presented on PostgreSQL, an open-source object-relational database system. PostgreSQL prioritizes reliability, security, and standards compliance. It supports Linux, Unix, Windows and is programmed through interfaces like C/C++, Java, .NET, PHP and Python. Common uses include ERP, data warehousing, and network tools. Prominent users include Yahoo, Sony, Reddit, and Skype. Key features include ACID compliance, online backup, point-in-time recovery, and SSL encryption.
MongoDB is the MashupDB
MongoDB is the MashupDBWynn Netherland This document provides an overview of MongoDB and discusses how it compares to traditional SQL databases. MongoDB is a document-oriented NoSQL database that uses dynamic schemas and stores data in JSON-like documents with schemaless collections. It discusses how MongoDB is versatile, scalable, and easy to install. It also summarizes some drivers and ORMs for Ruby, like MongoMapper, that make it easy to interact with MongoDB from Ruby applications.
Introduction to RDFa
Introduction to RDFaIvan Herman This document summarizes an Ivan Herman presentation on RDFa at the 2011 Semantic Technologies Conference. The presentation introduces RDFa as a way to serialize RDF embedded in HTML/XML pages. It discusses how RDFa allows adding structured data to web pages while keeping them usable by browsers. RDFa reuses existing HTML attributes and defines a mapping to extract RDF triples from pages for processing by specialized applications.
RDFa Tutorial
RDFa TutorialIvan Herman The document discusses RDFa, a mechanism for embedding RDF data within HTML, XHTML, or XML documents, simplifying the process of creating structured data on the web. It highlights the flexibility of RDFa in using namespaces, URIs, and various attributes, making it easier for developers to generate RDF without needing separate files. Additionally, the text compares RDFa with microformats and microdata, emphasizing its advantages in vocabulary management and data extraction.
Catmandu Librecat
Catmandu LibrecatPatrick Hochstenbach The document discusses three hypotheses for building a unified digital library system: 1) Using a network and common schema, 2) An object-oriented design approach, and 3) Viewing the researcher as central. It then describes the Catmandu toolkit for importing, processing, and storing data in various formats. Catmandu uses a functional programming approach and includes tools for extraction, transformation, loading, indexing, searching, and storing data in databases or search indexes. The document concludes by introducing the LibreCat project which provides example programs and applications built using Catmandu.
State of the Semantic Web
State of the Semantic WebIvan Herman The document discusses the current state of the Semantic Web as of May 2008, highlighting the stability of foundational technologies like RDF and OWL, the emergence of standards such as SPARQL for querying data, and the proliferation of tools and vocabularies that facilitate the creation and management of RDF data. It emphasizes the growth of communities and resources supporting RDF-based applications across various industries, while also addressing the challenges that remain, such as interoperability, security, and the integration of existing data sources. The document outlines ongoing efforts to improve standards and enhance the Semantic Web's functionality for better data management and knowledge integration.
DataFrame: Spark's new abstraction for data science by Reynold Xin of Databricks
DataFrame: Spark's new abstraction for data science by Reynold Xin of DatabricksData Con LA Spark DataFrames provide a unified data structure and API for distributed data processing across Python, R and Scala. DataFrames allow users to manipulate distributed datasets using familiar data frame concepts from single machine tools like Pandas and dplyr. The DataFrame API is built on a logical query plan called Catalyst that is optimized for efficient execution across different languages and Spark execution engines like Tungsten.
RDF SHACL, Annotations, and Data Frames
RDF SHACL, Annotations, and Data FramesKurt Cagle The document discusses the importance of RDF (Resource Description Framework) in relation to XML, and how it can create navigational infrastructure and support hybrid data systems. It introduces SHACL (Shapes Constraint Language), which offers a way to define constraints for RDF data, similar to XML Schema Definition (XSD), and highlights its impact on XML development. Additionally, it covers open web annotations and data cubes, emphasizing their roles in managing metadata and multi-dimensional data within a standardized framework.
OrientDB & Node.js Overview - JS.Everywhere() KW
OrientDB & Node.js Overview - JS.Everywhere() KWgmccarvell The document discusses OrientDB, a document-graph database. It provides an overview of key OrientDB concepts like documents, vertices, edges, classes, clusters, and properties. It also compares the relational and graph data models. The presentation was given by Greg McCarvell and introduces Node.js integration with OrientDB through examples.
Visualizing Web Data Query Results
Visualizing Web Data Query ResultsAnja Jentzsch This document outlines a tutorial on visualizing web data by processing SPARQL query results. It discusses preliminaries like using JavaScript and jQuery to send queries. It then covers manually parsing and displaying SPARQL JSON results by building a table. Pre-built toolkits like Sparqk and Sgvizler that simplify this process are also introduced. The document concludes by providing hands-on examples for attendees to try.
Big Data Processing using Apache Spark and Clojure
Big Data Processing using Apache Spark and ClojureDr. Christian Betz The document provides an overview of big data processing using Apache Spark with a focus on Clojure. It discusses the advantages of Spark's in-memory processing over Hadoop's traditional disk I/O, introduces Resilient Distributed Datasets (RDDs), and presents practical examples of RDD manipulation and transformations. The authors highlight the functional programming aspects of Spark that align well with Clojure, promoting its use for developing Spark applications.
Backbone using Extensible Database APIs over HTTP
Backbone using Extensible Database APIs over HTTPMax Neunhöffer The document discusses the evolution and benefits of using Backbone.js and ArangoDB in software architecture, particularly in microservices. It outlines different development phases (initial, consolidation, polishing) and emphasizes the importance of a flexible, extensible database that supports rapid development while ensuring performance and security. The goal is to create a smart database that can adapt over time through an extensible API and robust query capabilities.
Hotcode 2013: Javascript in a database (Part 2)
Hotcode 2013: Javascript in a database (Part 2)ArangoDB Database The document discusses ArangoDB's Foxx framework, which enables developers to create REST APIs directly interfacing with the database using JavaScript. It highlights the ease of developing single page applications and the streamlined API creation focused on front-end developers. Key features include the ability to define routes, handle parameters, and automate documentation generation.
More Related Content
What's hot (20)
A Graph Database That Scales - ArangoDB 3.7 Release Webinar
A Graph Database That Scales - ArangoDB 3.7 Release WebinarArangoDB Database The document outlines the features of ArangoDB version 3.7, highlighting improvements in graph performance, ArangoSearch capabilities, cluster scalability, and security enhancements. Key updates include parallel graph traversals, fuzzy search options, incremental plan updates, and schema validation. The document also mentions the deprecation of the mmfiles storage engine and introduces ArangoDB Oasis for cloud deployment.
Multi-model databases and node.js
Multi-model databases and node.jsMax Neunhöffer The document discusses multi-model databases, highlighting the combination of document stores, graph databases, and key/value stores within a single database system. It emphasizes the advantages of polyglot persistence while addressing the challenges of managing multiple database systems. The proposed multi-model database supports various data models and provides a framework for extensibility and convenience in data management.
A Little SPARQL in your Analytics
A Little SPARQL in your AnalyticsDr. Neil Brittliff The document discusses Semantic Web technologies including RDF, SPARQL and ontologies. It provides:
1) An introduction to the Semantic Web vision of machines being able to understand and respond to complex requests based on meaning. This requires information to be semantically structured.
2) A brief overview of key concepts in RDF including triples, nodes, blank nodes, and predefined RDF structures like bags and lists.
3) An explanation of the SPARQL query language, which is similar to SQL but interrogates the Semantic Web. SPARQL clauses like SELECT, CONSTRUCT, DESCRIBE and ASK are covered.
4) A discussion of ontological representations including R
Comparison with storing data using NoSQL(CouchDB) and a relational database.
Comparison with storing data using NoSQL(CouchDB) and a relational database.eross77 The document provides an introduction to NoSQL, particularly focusing on CouchDB, which stores data in JSON documents and supports replication and accessibility through a REST API. It discusses various features and characteristics of NoSQL databases, including ease of deployment and the absence of a required schema. Additionally, it compares popular NoSQL document stores like MongoDB, CouchDB, Couchbase, and Redis, highlighting their unique attributes and use cases.
Visualize your graph database
Visualize your graph databaseMichael Hackstein Michael Hackstein discusses techniques to visualize and manage graph data using a web-based administration interface. The document highlights the technology stack including D3.js for rendering and ArangoDB for data storage and querying, while addressing challenges like graph size and readability. Various exploration methods and visual techniques such as vertex grouping and fish-eye distortion are also explored.
Small Overview of Skype Database Tools
Small Overview of Skype Database Toolselliando dias Skype uses PostgreSQL for over 100 database servers and 200 databases to support its online services. It partitions data across multiple databases for scalability and uses tools like pgBouncer, PL/Proxy, SkyTools, PgQ, and Londiste to connect, load balance, and replicate data between databases. This complex database architecture has allowed Skype to grow significantly while remaining easy to manage.
Solid pods and the future of the spatial web
Solid pods and the future of the spatial webKurt Cagle This document discusses Solid Pods and their potential role in the future of the spatial web. Solid Pods are small, deployable graph databases that follow the principles of the Solid project, including allowing individuals to own and have granular control over their data. Solid Pods address issues that limited the adoption of earlier semantic web efforts. They could store scene graphs, serve as data catalogs, support distributed ledgers, and more. As graph databases, Pods are well-suited to power spatial applications through capabilities like hosting knowledge graphs and serving as intermediate calculation nodes. Standards bodies are exploring how Spatial Web specifications could adopt and extend the Solid Pod architecture.
An introduction to Nosql
An introduction to Nosqlgreprep This document provides an introduction to NoSQL databases. It describes NoSQL as non-relational, distributed, open-source databases that are horizontally scalable with no predefined schema. It lists the main types of NoSQL databases as document stores, graph stores, key-value stores, and wide-column stores. The document gives MongoDB as an example of a document database and explains that sharding allows horizontal scaling by storing data records across multiple machines.
OrientDB: Unlock the Value of Document Data Relationships
OrientDB: Unlock the Value of Document Data RelationshipsFabrizio Fortino The document discusses OrientDB, a multi-model database that integrates document and graph database functionalities. It emphasizes the importance of considering non-relational data storage options in the context of increasing amounts of unstructured data and the complexity of data relationships. The presentation outlines the features, applications, and advantages of using OrientDB for managing and querying complex data interactions efficiently.
PostgreSQL - Object Relational Database
PostgreSQL - Object Relational DatabaseMubashar Iqbal Mubashar Iqbal presented on PostgreSQL, an open-source object-relational database system. PostgreSQL prioritizes reliability, security, and standards compliance. It supports Linux, Unix, Windows and is programmed through interfaces like C/C++, Java, .NET, PHP and Python. Common uses include ERP, data warehousing, and network tools. Prominent users include Yahoo, Sony, Reddit, and Skype. Key features include ACID compliance, online backup, point-in-time recovery, and SSL encryption.
MongoDB is the MashupDB
MongoDB is the MashupDBWynn Netherland This document provides an overview of MongoDB and discusses how it compares to traditional SQL databases. MongoDB is a document-oriented NoSQL database that uses dynamic schemas and stores data in JSON-like documents with schemaless collections. It discusses how MongoDB is versatile, scalable, and easy to install. It also summarizes some drivers and ORMs for Ruby, like MongoMapper, that make it easy to interact with MongoDB from Ruby applications.
Introduction to RDFa
Introduction to RDFaIvan Herman This document summarizes an Ivan Herman presentation on RDFa at the 2011 Semantic Technologies Conference. The presentation introduces RDFa as a way to serialize RDF embedded in HTML/XML pages. It discusses how RDFa allows adding structured data to web pages while keeping them usable by browsers. RDFa reuses existing HTML attributes and defines a mapping to extract RDF triples from pages for processing by specialized applications.
RDFa Tutorial
RDFa TutorialIvan Herman The document discusses RDFa, a mechanism for embedding RDF data within HTML, XHTML, or XML documents, simplifying the process of creating structured data on the web. It highlights the flexibility of RDFa in using namespaces, URIs, and various attributes, making it easier for developers to generate RDF without needing separate files. Additionally, the text compares RDFa with microformats and microdata, emphasizing its advantages in vocabulary management and data extraction.
Catmandu Librecat
Catmandu LibrecatPatrick Hochstenbach The document discusses three hypotheses for building a unified digital library system: 1) Using a network and common schema, 2) An object-oriented design approach, and 3) Viewing the researcher as central. It then describes the Catmandu toolkit for importing, processing, and storing data in various formats. Catmandu uses a functional programming approach and includes tools for extraction, transformation, loading, indexing, searching, and storing data in databases or search indexes. The document concludes by introducing the LibreCat project which provides example programs and applications built using Catmandu.
State of the Semantic Web
State of the Semantic WebIvan Herman The document discusses the current state of the Semantic Web as of May 2008, highlighting the stability of foundational technologies like RDF and OWL, the emergence of standards such as SPARQL for querying data, and the proliferation of tools and vocabularies that facilitate the creation and management of RDF data. It emphasizes the growth of communities and resources supporting RDF-based applications across various industries, while also addressing the challenges that remain, such as interoperability, security, and the integration of existing data sources. The document outlines ongoing efforts to improve standards and enhance the Semantic Web's functionality for better data management and knowledge integration.
DataFrame: Spark's new abstraction for data science by Reynold Xin of Databricks
DataFrame: Spark's new abstraction for data science by Reynold Xin of DatabricksData Con LA Spark DataFrames provide a unified data structure and API for distributed data processing across Python, R and Scala. DataFrames allow users to manipulate distributed datasets using familiar data frame concepts from single machine tools like Pandas and dplyr. The DataFrame API is built on a logical query plan called Catalyst that is optimized for efficient execution across different languages and Spark execution engines like Tungsten.
RDF SHACL, Annotations, and Data Frames
RDF SHACL, Annotations, and Data FramesKurt Cagle The document discusses the importance of RDF (Resource Description Framework) in relation to XML, and how it can create navigational infrastructure and support hybrid data systems. It introduces SHACL (Shapes Constraint Language), which offers a way to define constraints for RDF data, similar to XML Schema Definition (XSD), and highlights its impact on XML development. Additionally, it covers open web annotations and data cubes, emphasizing their roles in managing metadata and multi-dimensional data within a standardized framework.
OrientDB & Node.js Overview - JS.Everywhere() KW
OrientDB & Node.js Overview - JS.Everywhere() KWgmccarvell The document discusses OrientDB, a document-graph database. It provides an overview of key OrientDB concepts like documents, vertices, edges, classes, clusters, and properties. It also compares the relational and graph data models. The presentation was given by Greg McCarvell and introduces Node.js integration with OrientDB through examples.
Visualizing Web Data Query Results
Visualizing Web Data Query ResultsAnja Jentzsch This document outlines a tutorial on visualizing web data by processing SPARQL query results. It discusses preliminaries like using JavaScript and jQuery to send queries. It then covers manually parsing and displaying SPARQL JSON results by building a table. Pre-built toolkits like Sparqk and Sgvizler that simplify this process are also introduced. The document concludes by providing hands-on examples for attendees to try.
Big Data Processing using Apache Spark and Clojure
Big Data Processing using Apache Spark and ClojureDr. Christian Betz The document provides an overview of big data processing using Apache Spark with a focus on Clojure. It discusses the advantages of Spark's in-memory processing over Hadoop's traditional disk I/O, introduces Resilient Distributed Datasets (RDDs), and presents practical examples of RDD manipulation and transformations. The authors highlight the functional programming aspects of Spark that align well with Clojure, promoting its use for developing Spark applications.
Viewers also liked (20)
Backbone using Extensible Database APIs over HTTP
Backbone using Extensible Database APIs over HTTPMax Neunhöffer The document discusses the evolution and benefits of using Backbone.js and ArangoDB in software architecture, particularly in microservices. It outlines different development phases (initial, consolidation, polishing) and emphasizes the importance of a flexible, extensible database that supports rapid development while ensuring performance and security. The goal is to create a smart database that can adapt over time through an extensible API and robust query capabilities.
Hotcode 2013: Javascript in a database (Part 2)
Hotcode 2013: Javascript in a database (Part 2)ArangoDB Database The document discusses ArangoDB's Foxx framework, which enables developers to create REST APIs directly interfacing with the database using JavaScript. It highlights the ease of developing single page applications and the streamlined API creation focused on front-end developers. Key features include the ability to define routes, handle parameters, and automate documentation generation.
Complex queries in a distributed multi-model database
Complex queries in a distributed multi-model databaseMax Neunhöffer The document discusses the structure and querying capabilities of a distributed multi-model database, highlighting the use of JSON documents and collections. It covers concepts such as sharding, graph modeling, various query types, and the process of query execution, including parsing, optimization, and execution planning. Additionally, it emphasizes the function of items in execution plans and their transformation through different stages of the processing pipeline.
GraphDatabases and what we can use them for
GraphDatabases and what we can use them forMichael Hackstein The document provides an overview of graphs and databases, outlining definitions, use cases, and examples of different types of graphs, including directed and undirected graphs. It discusses how to store graphs and perform queries using ArangoDB, highlighting the mechanisms for traversing and visualizing graph data. Additionally, it includes practical demonstrations on creating databases, adding edges, and executing traversals.
Extensible Database APIs and their role in Software Architecture
Extensible Database APIs and their role in Software ArchitectureMax Neunhöffer The document discusses the evolution of software architecture, emphasizing the importance of extensible database APIs in the context of agile development and microservices. It outlines various phases of development from rapid prototyping to consolidation, highlighting key features and considerations such as database schema, performance, and security. The paper advocates for a multi-model database solution with an extensible API, particularly highlighting ArangoDB's capabilities for creating configurable and performance-critical microservices.
Domain Driven Design & NoSQL
Domain Driven Design & NoSQLArangoDB Database Domain Driven Design is an approach to software development that focuses on the domain and domain experts. It involves finding a common language to describe the domain that all parties understand, and building a model of the domain that evolves alongside the implementation. NoSQL databases like ArangoDB are useful for implementing Domain Driven Design because they allow flexible data models and relationships that can match the domain model.
ArangoDB – Persistência Poliglota e Banco de Dados Multi-Modelos
ArangoDB – Persistência Poliglota e Banco de Dados Multi-ModelosHelder Santana Nesta palestra, apresento uma breve introdução ao mundo do banco de dados NoSQL, apontando os benefícios da persistência poliglota. Apresento o ArangoDB, um banco de dados universal de código aberto com um modelo de dados flexível para documentos, grafos e chave-valor. Crie aplicativos de alto desempenho usando uma linguagem de consulta sql-like ou extensões JavaScript/Ruby.
Domain Driven Design & NoSQL
Domain Driven Design & NoSQLArangoDB Database The document discusses the principles of Domain Driven Design (DDD) and its relationship with NoSQL databases, specifically focusing on ArangoDB. It emphasizes the importance of creating an ubiquitous language among developers and domain experts to facilitate understanding and collaboration. Additionally, it explores concepts like document stores, the use of multi-model databases, and the iterative development process in building a cohesive model.
Multi model-databases
Multi model-databasesArangoDB Database The document discusses polyglot persistence and multi-model databases, emphasizing the importance of using the appropriate database type for specific data needs, such as key-value stores, document stores, and graph databases. It highlights ArangoDB as a notable multi-model database that integrates various data formats without the need for transformation, offering flexible querying and performance advantages. Additionally, it outlines the complexity of existing query languages and promotes ArangoDB's user-friendly query language (AQL) designed for high efficiency and ease of use.
Jan Steemann: Modelling data in a schema free world (Talk held at Froscon, 2...
Jan Steemann: Modelling data in a schema free world (Talk held at Froscon, 2...ArangoDB Database The document discusses the limitations of relational databases, particularly their rigid schemas and scalability challenges, and introduces NoSQL databases as an alternative that provides flexibility and easier scaling. It categorizes various types of NoSQL databases, such as key-value stores, wide column stores, document stores, and graph databases, emphasizing their unique features and use cases. Additionally, it highlights the importance of data modeling, even in schema-less environments, to ensure optimal performance and data retrieval.
Processing large-scale graphs with Google(TM) Pregel by MICHAEL HACKSTEIN at...
Processing large-scale graphs with Google(TM) Pregel by MICHAEL HACKSTEIN at...Big Data Spain The document discusses processing large-scale graphs using Google Pregel, a distributed graph processing framework akin to MapReduce. It covers graph algorithms, component identification, and global measurements, and illustrates the Pregel workflow, including mapping, reducing, and activity termination. Additionally, practical examples of algorithms like PageRank are provided, alongside insights into their implementation in ArangoDB.
Overhauling a database engine in 2 months
Overhauling a database engine in 2 monthsMax Neunhöffer The document outlines the development of ArangoDB, a multi-model database, and its transition to include a write-ahead log (WAL) for improved transaction management and performance. It details the challenges faced in reengineering the database engine, the planned approach phases, and the extensive testing and methodologies implemented to ensure successful integration without degrading user experience. ArangoDB is open source, widely supported, and designed for high efficiency with capabilities for complex queries and schema-less data processing.
guacamole: an Object Document Mapper for ArangoDB
guacamole: an Object Document Mapper for ArangoDBMax Neunhöffer Guacamole is an object document mapper for Ruby that builds on the ArangoDB driver ashikawa-core. It implements the data mapper pattern to provide models and collections for working with ArangoDB documents and graphs. Models validate attributes and are saved to collections, which provide access to the database. Relations between objects can be represented through embedding or references using ArangoDB graphs.
Domain driven design @FrOSCon
Domain driven design @FrOSConArangoDB Database The document discusses domain-driven design and NoSQL databases. It introduces domain-driven design principles like defining a ubiquitous language within a domain. It then explains some differences between SQL and NoSQL databases, providing examples of document and graph databases in NoSQL. The document advocates finding a common language within a domain and evolving data models iteratively with implementation.
Processing large-scale graphs with Google Pregel
Processing large-scale graphs with Google PregelMax Neunhöffer The document discusses the implementation of Pregel, a framework for processing large-scale graphs, utilizing a map-reduce approach tailored for graph data structures. It details the different types of graph algorithms, the multi-model database capabilities of ArangoDB, and features of the Foxx microservice framework for extending database operations. The emphasis is on Pregel's efficient operation for distributed graphs, allowing for custom queries and real-time data processing.
Wir sind aber nicht Twitter
Wir sind aber nicht TwitterArangoDB Database Das Dokument befasst sich mit NoSQL-Datenbanken, die eine flexible, schemafreie Struktur bieten und sich von traditionellen relationalen Datenbanken unterscheiden. Es werden verschiedene Typen von NoSQL-Datenbanken wie Dokumenten- und Graphdatenbanken vorgestellt, sowie deren Vorteile wie Skalierbarkeit und einfache Entwicklung. Außerdem wird auf die Herausforderungen und Optimierungen eingegangen, die mit der Verwaltung von Daten in Massensystemen verbunden sind.
Domain Driven Design and NoSQL TLV
Domain Driven Design and NoSQL TLVArangoDB Database The document discusses the alignment between Domain Driven Design (DDD) and NoSQL databases. It explains key DDD concepts like entities, value objects, aggregates, and associations, and how they map to constructs in document databases, graph databases, and multi-model databases. The document concludes that DDD and multi-model NoSQL databases are well-suited for each other, as both advocate for a shared language between technical and business teams and allow modeling of complex domains.
Introduction to ArangoDB (nosql matters Barcelona 2012)
Introduction to ArangoDB (nosql matters Barcelona 2012)ArangoDB Database - The document discusses ArangoDB, an open source multi-model database that supports documents, graphs, and key-value stores.
- It began development in 2011 and reached version 1.0 in 2012. The database aims to provide a universal solution as requirements change and scale.
- ArangoDB offers high performance, a query language, extensions via actions, and supports features like replication and sharding.
CAP and the Architectural Consequences by martin Schönert
CAP and the Architectural Consequences by martin SchönertArangoDB Database This document discusses the CAP theorem and its implications for database system architecture. It describes the CAP theorem, which states that a distributed system can only guarantee two of three properties: consistency, availability, and partition tolerance. It then discusses criticisms of how CAP is often interpreted too strictly. The document explores how databases can achieve different properties in normal operation versus when network partitions are detected. It also addresses the challenges of applying CAP to massively distributed databases that must be highly available and tolerant of frequent failures.
Introduction to column oriented databases
Introduction to column oriented databasesArangoDB Database Column-oriented databases store data by column rather than by row. This allows fast retrieval of entire columns of data with one read operation. Column-oriented databases are well-suited for analytical queries that retrieve many rows but only a few columns, as only the needed columns are read from disk. Row-oriented databases are better for transactional queries that retrieve or update individual rows. The type of data storage - row-oriented or column-oriented - depends on the types of queries that will be run against the data.
Ad
Similar to Running MRuby in a Database - ArangoDB - RuPy 2012 (20)
Drill dchug-29 nov2012
Drill dchug-29 nov2012MapR Technologies Apache Drill is an open source SQL query engine for analysis of large scale datasets. It is modeled after Google's Dremel system and allows for interactive analysis of data stored in Hadoop files. Drill uses a columnar data format and execution engine to enable fast query performance on large datasets. It also supports pluggable components for different data formats, query languages, and data sources to provide a flexible and extensible platform.
CloudFoundry and MongoDb, a marriage made in heaven
CloudFoundry and MongoDb, a marriage made in heavenPatrick Chanezon The document discusses the integration of Cloud Foundry with MongoDB, highlighting the advantages of using NoSQL databases for scalable applications deployed in the cloud. It details the functionalities of the Spring Framework for data access, including MongoDB support for CRUD operations and repositories. Additionally, the document outlines Cloud Foundry's capabilities as an open PaaS, emphasizing its multi-cloud and multi-language frameworks.
Nosql and newsql
Nosql and newsqlZhongke Chen This document discusses NoSQL and NewSQL databases. It describes the typical data models for NoSQL databases, including key-value, column family, document and graph models. Popular NoSQL databases like Redis, MongoDB, CouchDB, and Cassandra are presented. NewSQL databases like VoltDB aim to provide SQL support and high performance like NoSQL. The document concludes with tips on choosing between these database types.
Realtime Analytics with MongoDB Counters (mongonyc 2012)
Realtime Analytics with MongoDB Counters (mongonyc 2012)Scott Hernandez This document discusses pre-aggregating data with counters in MongoDB to enable dashboard-style reports. It involves defining metrics and aggregations upfront, and using the $inc operator to increment values in aggregation collections during write operations. This allows generating real-time aggregated data without requiring map-reduce or the aggregation framework, providing better performance for dashboard queries.
PhillyDB Talk - Beyond Batch
PhillyDB Talk - Beyond Batchboorad The document discusses the performance benchmarks of MapR technologies, comparing speed and throughput with traditional Hadoop implementations, particularly highlighting improvements in interactive and real-time query capabilities. It outlines the functionalities of tools like Apache Drill and Storm, emphasizing their extensibility, fault tolerance, and integration with various data sources. The presentation also includes insights into system architecture, query language support, and user community engagement around these technologies.
Drupal and the rise of the documents
Drupal and the rise of the documentsClaudio Beatrice This document discusses Drupal and MongoDB. It provides an overview of MongoDB as a document-oriented and schema-less database and compares its flexibility, power, speed, and scaling to relational databases. It also describes several Drupal modules that integrate MongoDB as a backend storage mechanism, including for blocks, caching, fields, sessions, queues, and search. Examples are provided of past sessions on using MongoDB with Drupal.
Hbase: Introduction to column oriented databases
Hbase: Introduction to column oriented databasesLuis Cipriani The document provides an introduction to HBase, a column-oriented database built on the Hadoop stack, highlighting its architecture, data model, and read/write strategies. It discusses the advantages of HBase, such as scalability and fault tolerance, as well as challenges like complex configuration and lack of built-in secondary indexing. Additionally, it touches on the development aspects and key design strategies relevant to using HBase.
StORM preview
StORM previewDavid Chandler This document provides an overview and introduction to stORM, a simple template-based Object Relational Mapping (ORM) library for Android. Key points include that stORM aims to provide an easy and convention-based way to map Android objects to SQLite tables using annotations with minimal performance overhead. It generates DAO and table classes but does not support modeling all possible relations or achieving absolute maximum performance.
NOSQL, CouchDB, and the Cloud
NOSQL, CouchDB, and the Cloudboorad Brad Anderson presented on NOSQL databases and CouchDB. He discussed how relational databases do not scale well and are rigid. NOSQL databases like CouchDB are a better fit for large, growing datasets. CouchDB is a document oriented database written in Erlang that uses a REST API and supports views and incremental replication. It can be deployed on a cloud platform to improve scalability, redundancy and query distribution.
Big Data for Mobile
Big Data for MobileBugSense BugSense is a company that analyzes data from 400 million mobile devices using custom databases built with Erlang, C, and Lisp. They process over 120,000 writes per second using their distributed, concurrent database called LDB. LDB is an in-memory time-series stream processor that allows for complex event processing and distributed, modular architecture through Erlang nodes. They use Lisp for custom data processing and views due to its expressive power for parallel computing on large datasets.
DevNation Atlanta
DevNation Atlantaboorad This document provides an overview of NoSQL databases and CouchDB. It discusses how NoSQL databases are a better fit than relational databases for large datasets and real-time applications. It then describes CouchDB, an open-source document-oriented NoSQL database, covering its features like schema-free documents, robustness, concurrency, REST API, views, replication, and deployment in the cloud. The document concludes with a discussion of Erlang and eventually demos CouchDB.
Bar Camp Auckland - Mongo DB Presentation BCA4
Bar Camp Auckland - Mongo DB Presentation BCA4John Ballinger MongoDB bridges the gap between key-value stores and traditional RDBMS systems by providing a document-oriented database with dynamic schemas. It offers features like replication, high availability, auto-sharding, rich querying and fast in-place updates. MongoDB is an open source, scalable and high-performance database that is supported by drivers in many languages.
Drill Bay Area HUG 2012-09-19
Drill Bay Area HUG 2012-09-19jasonfrantz This document discusses Apache Drill, an open source interactive analysis engine for large scale datasets. It was designed to provide interactive query performance over large datasets like Google's Dremel. Drill uses a columnar data format and distributed execution model to enable fast analysis. It supports pluggable query languages, data formats, and data sources to provide a flexible platform for interactive exploration of large datasets.
Sep 2012 HUG: Apache Drill for Interactive Analysis
Sep 2012 HUG: Apache Drill for Interactive Analysis Yahoo Developer Network Apache Drill is designed for interactive analysis of large-scale datasets, offering capabilities to process trillions of records at high speeds while supporting multiple data models. It features a flexible architecture that allows extensibility for different query languages and data formats, enabling efficient performance with both nested and flat records. The integration with Hadoop enhances its ability to handle massive data sources and formats, making it suitable for diverse applications across various industries.
Apache Drill @ PJUG, Jan 15, 2013
Apache Drill @ PJUG, Jan 15, 2013Gera Shegalov The document discusses Apache Drill, an open-source project designed for low-latency interactive queries and optimized for handling large data sets across various data models. It details its extensible architecture, compatibility with different query languages, and integration with Hadoop ecosystems, while emphasizing its scalability and performance in big data processing. Additionally, it invites contributions and participation from the community for ongoing development and expansion.
Drill at the Chug 9-19-12
Drill at the Chug 9-19-12Ted Dunning This document discusses Apache Drill, an open-source interactive analysis tool designed for large-scale datasets, emphasizing its capabilities in real-time data processing and multi-format support. It highlights Drill's architecture, which allows extensibility for new query languages and scalability across various data sources and formats. Additionally, it covers the integration of Drill with Hadoop and its deployment in numerous enterprises for analyzing vast amounts of data efficiently.
MongoGraph - MongoDB Meets the Semantic Web
MongoGraph - MongoDB Meets the Semantic WebDATAVERSITY The document discusses the author's excitement about attending a MongoDB talk and their own experimentation with MongoDB and AllegroGraph. It raises questions about enhancing AllegroGraph's freetext capabilities and improving document handling like MongoDB. Additionally, it invites users to share innovative MongoDB applications and mentions research and development goals involving social network analysis and integration of tools.
Deep dive into the native multi model database ArangoDB
Deep dive into the native multi model database ArangoDBArangoDB Database The document describes ArangoDB, a multi-model database that can function as a document store, key-value store, and graph database. It offers querying across these models using its AQL language. The document also discusses how ArangoDB is extensible through JavaScript, can run as a microservice using Foxx, and integrates with data center operating systems like Mesosphere DC/OS for resource management and fault tolerance.
FP Days: Down the Clojure Rabbit Hole
FP Days: Down the Clojure Rabbit HoleChristophe Grand The document discusses the author's journey with functional programming languages and Clojure specifically. It covers the author's background and interests that led to Clojure, key features of Clojure like immutability and persistent data structures, approaches to modeling data and processes, and ideas around computation and efficiency in a functional style.
BRAINREPUBLIC - Powered by no-SQL
BRAINREPUBLIC - Powered by no-SQLAndreas Jung The document summarizes Andreas Jung's presentation on using MongoDB as the database for BRAINREPUBLIC. Some key points include:
- Andreas evaluated different "no-SQL" database options for BRAINREPUBLIC including key-value stores, MongoDB, and CouchDB.
- MongoDB was chosen because it offered the best performance compared to CouchDB, and its rich query API was preferable to map-reduce alone.
- The proposed architecture for BRAINREPUBLIC involved using MongoDB for the database, RabbitMQ for messaging, and SOLR for search, behind a load balancing layer.
Ad
More from ArangoDB Database (20)
ATO 2022 - Machine Learning + Graph Databases for Better Recommendations (3)....
ATO 2022 - Machine Learning + Graph Databases for Better Recommendations (3)....ArangoDB Database This document summarizes techniques for combining machine learning and graph databases for better recommendations. It discusses using collaborative filtering with AQL, content-based recommendations with TFIDF and FAISS, and graph neural networks with PyTorch. The document also describes an ArangoFlix demo project that combines these techniques on a movie recommendation system using ArangoDB as the backend graph database.
Machine Learning + Graph Databases for Better Recommendations V2 08/20/2022
Machine Learning + Graph Databases for Better Recommendations V2 08/20/2022ArangoDB Database The document discusses the integration of machine learning and graph databases to enhance recommendation systems, with a focus on the Arangoflix project. It outlines various techniques such as collaborative filtering, content-based recommendations, and graph neural networks, emphasizing the importance of data relationships in AI and ML models. Additionally, it presents use cases, methodologies, and tools involved in developing intelligent recommendation systems using ArangoDB.
Machine Learning + Graph Databases for Better Recommendations V1 08/06/2022
Machine Learning + Graph Databases for Better Recommendations V1 08/06/2022ArangoDB Database The document discusses the integration of machine learning and graph databases for improving recommendation systems, particularly through the ArangoDB and its Arangoflix project. It covers various techniques including collaborative filtering, content-based recommendations, and the use of graph neural networks. It outlines the advantages of graph databases in handling complex relationships and offers practical applications across diverse domains such as product recommendations and customer analysis.
ArangoDB 3.9 - Further Powering Graphs at Scale
ArangoDB 3.9 - Further Powering Graphs at ScaleArangoDB Database The document details the features and advancements of ArangoDB 3.9, including scalable graph technology and smartgraphs that enhance data distribution and query optimization. It outlines upcoming features in future releases (3.10 and 4.0) such as improved user interface, enterprise graph capabilities, and enhanced data model functionalities. Additionally, community initiatives and interactive tutorials are mentioned to foster user engagement and knowledge sharing.
GraphSage vs Pinsage #InsideArangoDB
GraphSage vs Pinsage #InsideArangoDBArangoDB Database The document discusses two graph machine learning algorithms, GraphSAGE and PinSAGE, with a focus on their applications in web-scale recommender systems, particularly by Pinterest. PinSAGE, built on top of GraphSAGE, is described as more efficient due to its ability to perform on-the-fly convolutions and support for mapreduce inference, while also handling a large-scale graph dataset. The comparison highlights PinSAGE's advantages, including inductive learning, improved neighborhood sampling, and support for curriculum training.
Webinar: ArangoDB 3.8 Preview - Analytics at Scale
Webinar: ArangoDB 3.8 Preview - Analytics at Scale ArangoDB Database The document outlines features and enhancements in ArangoDB version 3.8, focusing on analytics at scale, including new AQL (ArangoDB Query Language) window operations for time series data, advanced graph traversals, and full-text search capabilities with ArangoSearch. It also discusses performance improvements, such as Merkle tree replication for faster synchronization, and provides insights into monitoring features compatible with Prometheus. Additionally, it highlights future roadmap goals for subsequent versions, including user interface improvements and enhanced query capabilities.
Graph Analytics with ArangoDB
Graph Analytics with ArangoDBArangoDB Database This document discusses using graphs and graph databases for machine learning. It provides an overview of graph analytics algorithms that can be used to solve problems with graph data, including recommendations, fraud detection, and network analysis. It also discusses using graph embeddings and graph neural networks for tasks like node classification and link prediction. Finally, it discusses how graphs can be used for machine learning infrastructure and metadata tasks like data provenance, audit trails, and privacy.
Getting Started with ArangoDB Oasis
Getting Started with ArangoDB OasisArangoDB Database The document is a confidential guide by ArangoDB Inc. focusing on creating and customizing database deployments. It covers initial deployment steps, configuration options, and includes sections on security and automation. The aim is to help users effectively set up and manage their deployments.
Custom Pregel Algorithms in ArangoDB
Custom Pregel Algorithms in ArangoDBArangoDB Database ArangoDB's Pregel framework simplifies distributed graph processing with support for predefined and customizable algorithms like PageRank and shortest path. The experimental feature allows users to add or modify algorithms dynamically without needing C++ code or restarting the database. Future developments will include gathering user feedback and enhancing the user-friendly front-end language in upcoming ArangoDB versions.
Hacktoberfest 2020 - Intro to Knowledge Graphs
Hacktoberfest 2020 - Intro to Knowledge GraphsArangoDB Database The document introduces knowledge graphs, graph databases, and their concepts such as RDF and OWL, emphasizing their use cases in various fields like recommendation engines and natural language processing. It defines a knowledge graph as a structured collection of data from multiple sources that improves accessibility and inference of new knowledge. Additional resources for learning about graph databases and knowledge graphics are also provided.
gVisor, Kata Containers, Firecracker, Docker: Who is Who in the Container Space?
gVisor, Kata Containers, Firecracker, Docker: Who is Who in the Container Space?ArangoDB Database The document discusses various container technologies and runtimes such as gVisor, Kata Containers, and Firecracker, outlining their architectures and use cases. It emphasizes the importance of container orchestration with Kubernetes, detailing features like scheduling, resource management, and service management. Additionally, it touches on security aspects and the evolution of container technology, urging users to consider their cloud provider and environment when selecting a runtime.
ArangoML Pipeline Cloud - Managed Machine Learning Metadata
ArangoML Pipeline Cloud - Managed Machine Learning MetadataArangoDB Database The document introduces ArangoML Pipeline Cloud, a managed solution for machine learning metadata, emphasizing the importance of data in the ML pipeline. It discusses features like a multi-model database, metadata management, performance auditing, and reproducible model building for data scientists. It also provides links for getting started and offers a demo of the capabilities of the platform.
ArangoDB 3.7 Roadmap: Performance at Scale
ArangoDB 3.7 Roadmap: Performance at ScaleArangoDB Database The document outlines the features and enhancements of ArangoDB 3.7, focusing on satellite graphs, improved graph performance, cluster failover capabilities, and security enhancements. It highlights the native multi-model database approach, supporting various data models and providing scalability and operability metrics. The roadmap for future developments is also discussed, including the deprecation of the mmfiles storage engine.
Webinar: What to expect from ArangoDB Oasis
Webinar: What to expect from ArangoDB OasisArangoDB Database The document is an agenda for a presentation about ArangoDB Oasis, focusing on its features and deployment models. It covers topics ranging from the transition to Oasis, security enhancements, account management, and future developments. The session also provides guidance on getting started and pricing options for users.
ArangoDB 3.5 Feature Overview Webinar - Sept 12, 2019
ArangoDB 3.5 Feature Overview Webinar - Sept 12, 2019ArangoDB Database The document discusses new features in ArangoDB 3.5, including improvements in the managed cloud service, distributed joins, and new capabilities within ArangoSearch. Notable updates include support for sorted inverted indexes, fuzzy searches, and enhanced graph functionalities. Additionally, it outlines future development plans and resources for further information.
3.5 webinar
3.5 webinar ArangoDB Database This document summarizes new features in ArangoDB version 3.5 including distributed joins, streaming transactions, expanded graph and search capabilities, hot backups, data masking, and time-to-live indexes. It also previews upcoming features like fuzzy search, autocomplete, and faceted search in ArangoSearch as well as k-shortest paths and pruning in graphs.
Webinar: How native multi model works in ArangoDB
Webinar: How native multi model works in ArangoDBArangoDB Database The document discusses the advantages of a native multi-model database approach, highlighting the benefits of using multiple data models for specific application needs and the challenges of single model databases. It outlines how organizations frequently utilize multiple database types, leading to increased complexity and cost. The presentation also introduces ArangoDB's capabilities, use cases, and a managed service option, emphasizing its performance and enterprise features.
An introduction to multi-model databases
An introduction to multi-model databasesArangoDB Database ArangoDB is a native multi-model database that supports key-values, documents, graphs, and provides a unified query language (AQL) for flexible data querying. It addresses issues associated with using multiple specialized databases by allowing different data models to be combined in a single system, enhancing composability and reducing integration complexity. The database also features a variety of deployment options and additional tools, such as a built-in microservice framework (Foxx) for easy data exposure via REST APIs.
Running complex data queries in a distributed system
Running complex data queries in a distributed systemArangoDB Database The document provides an overview of ArangoDB, a distributed, multi-model database designed for complex queries and transactions. It discusses the architecture of distributed databases, the coordination of queries across multiple nodes, and the implementation of ACID transactions. Additionally, it includes examples of query syntax in ArangoDB's query language, AQL, and outlines recent trends in the database landscape towards enhanced query functionality and scalability.
Guacamole Fiesta: What do avocados and databases have in common?
Guacamole Fiesta: What do avocados and databases have in common?ArangoDB Database The document introduces ArangoDB, a multi-model database aimed at enhancing developer productivity, detailing its features, use cases, and community resources. It outlines the capability of handling complex queries across graph, document, and key-value models, highlighting performance improvements and advanced functionalities like Foxx for microservice architectures. Several examples of data models and access rights are provided, along with a focus on scaling strategies like sharding and replication.
Recently uploaded (20)
AI vs Human Writing: Can You Tell the Difference?
AI vs Human Writing: Can You Tell the Difference?Shashi Sathyanarayana, Ph.D This slide illustrates a side-by-side comparison between human-written, AI-written, and ambiguous content. It highlights subtle cues that help readers assess authenticity, raising essential questions about the future of communication, trust, and thought leadership in the age of generative AI.
From Manual to Auto Searching- FME in the Driver's Seat
From Manual to Auto Searching- FME in the Driver's SeatSafe Software Finding a specific car online can be a time-consuming task, especially when checking multiple dealer websites. A few years ago, I faced this exact problem while searching for a particular vehicle in New Zealand. The local classified platform, Trade Me (similar to eBay), wasn’t yielding any results, so I expanded my search to second-hand dealer sites—only to realise that periodically checking each one was going to be tedious. That’s when I noticed something interesting: many of these websites used the same platform to manage their inventories. Recognising this, I reverse-engineered the platform’s structure and built an FME workspace that automated the search process for me. By integrating API calls and setting up periodic checks, I received real-time email alerts when matching cars were listed. In this presentation, I’ll walk through how I used FME to save hours of manual searching by creating a custom car-finding automation system. While FME can’t buy a car for you—yet—it can certainly help you find the one you’re after!
AI VIDEO MAGAZINE - June 2025 - r/aivideo
AI VIDEO MAGAZINE - June 2025 - r/aivideo1pcity Studios, Inc AI VIDEO MAGAZINE - r/aivideo community newsletter – Exclusive Tutorials: How to make an AI VIDEO from scratch, PLUS: How to make AI MUSIC, Hottest ai videos of 2025, Exclusive Interviews, New Tools, Previews, and MORE - JUNE 2025 ISSUE -
Security Tips for Enterprise Azure Solutions
Security Tips for Enterprise Azure SolutionsMichele Leroux Bustamante Delivering solutions to Azure may involve a variety of architecture patterns involving your applications, APIs data and associated Azure resources that comprise the solution. This session will use reference architectures to illustrate the security considerations to protect your Azure resources and data, how to achieve Zero Trust, and why it matters. Topics covered will include specific security recommendations for types Azure resources and related network security practices. The goal is to give you a breadth of understanding as to typical security requirements to meet compliance and security controls in an enterprise solution.
Wenn alles versagt - IBM Tape schützt, was zählt! Und besonders mit dem neust...
Wenn alles versagt - IBM Tape schützt, was zählt! Und besonders mit dem neust...Josef Weingand IBM LTO10
Coordinated Disclosure for ML - What's Different and What's the Same.pdf
Coordinated Disclosure for ML - What's Different and What's the Same.pdfPriyanka Aash Coordinated Disclosure for ML - What's Different and What's the Same
EIS-Webinar-Engineering-Retail-Infrastructure-06-16-2025.pdf
EIS-Webinar-Engineering-Retail-Infrastructure-06-16-2025.pdfEarley Information Science As AI reshapes expectations in retail and B2B commerce, organizations are recognizing a critical reality: meaningful AI outcomes depend on well-structured, adaptable infrastructure. In this session, Seth Earley is joined by Phil Ryan - AI strategist, search technologist, and founder of Glass Leopard Technologies - for a candid conversation on what it truly means to engineer systems for scale, agility, and intelligence.
Phil draws on more than two decades of experience leading search and AI initiatives for enterprise organizations. Together, he and Seth explore the challenges businesses face when legacy architectures limit personalization, agility, and real-time decisioning - and what needs to change to support agentic technologies and next-best-action capabilities.
Key themes from the webinar include:
Composability as a prerequisite for AI - Why modular, loosely coupled systems are essential for adapting to rapid innovation and evolving business needs
Search and relevance as foundational to AI - How techniques honed-in enterprise search have laid the groundwork for more responsive and intelligent customer experiences
From MDM and CDP to agentic systems - How data platforms are evolving to support richer customer context and dynamic orchestration
Engineering for business alignment - Why successful AI programs require architectural decisions grounded in measurable outcomes
The conversation is practical and forward-looking, connecting deep technical understanding with real-world business needs. Whether you’re modernizing your commerce stack or exploring how AI can enhance product discovery, personalization, or customer journeys, this session provides a clear-eyed view of the capabilities, constraints, and priorities that matter most.
Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdf
Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdfPriyanka Aash Cracking the Code - Unveiling Synergies Between Open Source Security and AI
cnc-processing-centers-centateq-p-110-en.pdf
cnc-processing-centers-centateq-p-110-en.pdfAmirStern2 מרכז עיבודים תעשייתי בעל 3/4/5 צירים, עד 22 החלפות כלים עם כל אפשרויות העיבוד הדרושות. בעל שטח עבודה גדול ומחשב נוח וקל להפעלה בשפה העברית/רוסית/אנגלית/ספרדית/ערבית ועוד..
מסוגל לבצע פעולות עיבוד שונות המתאימות לענפים שונים: קידוח אנכי, אופקי, ניסור, וכרסום אנכי.
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdf
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdfcaoyixuan2019 A presentation at Internetware 2025.
9-1-1 Addressing: End-to-End Automation Using FME
9-1-1 Addressing: End-to-End Automation Using FMESafe Software This session will cover a common use case for local and state/provincial governments who create and/or maintain their 9-1-1 addressing data, particularly address points and road centerlines. In this session, you'll learn how FME has helped Shelby County 9-1-1 (TN) automate the 9-1-1 addressing process; including automatically assigning attributes from disparate sources, on-the-fly QAQC of said data, and reporting. The FME logic that this presentation will cover includes: Table joins using attributes and geometry, Looping in custom transformers, Working with lists and Change detection.
A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy.pdf
A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy.pdfPriyanka Aash A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy
Curietech AI in action - Accelerate MuleSoft development
Curietech AI in action - Accelerate MuleSoft developmentshyamraj55 CurieTech AI in Action – Accelerate MuleSoft Development
Overview:
This presentation demonstrates how CurieTech AI’s purpose-built agents empower MuleSoft developers to create integration workflows faster, more accurately, and with less manual effort
linkedin.com
+12
curietech.ai
+12
meetups.mulesoft.com
+12
.
Key Highlights:
Dedicated AI agents for every stage: Coding, Testing (MUnit), Documentation, Code Review, and Migration
curietech.ai
+7
curietech.ai
+7
medium.com
+7
DataWeave automation: Generate mappings from tables or samples—95%+ complete within minutes
linkedin.com
+7
curietech.ai
+7
medium.com
+7
Integration flow generation: Auto-create Mule flows based on specifications—speeds up boilerplate development
curietech.ai
+1
medium.com
+1
Efficient code reviews: Gain intelligent feedback on flows, patterns, and error handling
youtube.com
+8
curietech.ai
+8
curietech.ai
+8
Test & documentation automation: Auto-generate MUnit test cases, sample data, and detailed docs from code
curietech.ai
+5
curietech.ai
+5
medium.com
+5
Why Now?
Achieve 10× productivity gains, slashing development time from hours to minutes
curietech.ai
+3
curietech.ai
+3
medium.com
+3
Maintain high accuracy with code quality matching or exceeding manual efforts
curietech.ai
+2
curietech.ai
+2
curietech.ai
+2
Ideal for developers, architects, and teams wanting to scale MuleSoft projects with AI efficiency
Conclusion:
CurieTech AI transforms MuleSoft development into an AI-accelerated workflow—letting you focus on innovation, not repetition.
OWASP Barcelona 2025 Threat Model Library
OWASP Barcelona 2025 Threat Model LibraryPetraVukmirovic Threat Model Library Launch at OWASP Barcelona 2025
https://owasp.org/www-project-threat-model-library/
" How to survive with 1 billion vectors and not sell a kidney: our low-cost c...
" How to survive with 1 billion vectors and not sell a kidney: our low-cost c...Fwdays Let's talk about our history. How we started the project with a small vector database of less than 2 million records. Later, we received a request for +100 million records, then another +100... And so gradually we reached almost 1 billion. Standard tools were quickly running out of steam - we were running into performance, index size, and very limited resources. After a long series of trials and errors, we built our own low-cost cluster, which today stably processes thousands of queries to more than 1B vectors.
PyCon SG 25 - Firecracker Made Easy with Python.pdf
PyCon SG 25 - Firecracker Made Easy with Python.pdfMuhammad Yuga Nugraha Explore the ease of managing Firecracker microVM with the firecracker-python. In this session, I will introduce the basics of Firecracker microVM and demonstrate how this custom SDK facilitates microVM operations easily. We will delve into the design and development process behind the SDK, providing a behind-the-scenes look at its creation and features. While traditional Firecracker SDKs were primarily available in Go, this module brings a simplicity of Python to the table.
OpenPOWER Foundation & Open-Source Core Innovations
OpenPOWER Foundation & Open-Source Core InnovationsIBM penPOWER offers a fully open, royalty-free CPU architecture for custom chip design.
It enables both lightweight FPGA cores (like Microwatt) and high-performance processors (like POWER10).
Developers have full access to source code, specs, and tools for end-to-end chip creation.
It supports AI, HPC, cloud, and embedded workloads with proven performance.
Backed by a global community, it fosters innovation, education, and collaboration.
Running MRuby in a Database - ArangoDB - RuPy 2012
- 1. Running MRuby in a database Totally awesome, useful or just another pointless approach? Frank Celler, triAGENS, Cologne RuPy 2012, Brno 2012-11-16 www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 2. Agenda NoSQL database ArangoDB Use-Cases for actions mruby V8 or mruby? www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 3. NoSQL Databases Key/Value Store Document (Object) DB Graph Database www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 4. NoSQL Databases 2012-11-11: 150 DB on nosql-databases.org Key/Value Store Document (Object) DB Graph Database www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 5. NoSQL Databases 2012-11-11: 150 DB on nosql-databases.org Key/Value Store Document (Object) DB Graph Database Multi-Model Databases Polyglot Persistence www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 6. Multi-Model Open-Source Database Various Indexes: Skip-Lists, Hashes, Geo, Cap Language API/Drivers for big Ps, Ruby, JS Embedded JavaScript & Ruby engine Written in C/C++ Query Language for Joins and Sub-Structures www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 7. Query Language: FOR u in Users FOR u IN users LET rs = ( LET friends = ( FOR r in Recommendations FOR p in PATHS(user, relations, ``outbound´´, 1) FILTER r.rec_by == u._id && r.type == "Book" FILTER p._from == u._id RETURN r.book_title ) ) FILTER RETURN length(rs) >= 3 { user: u, closeFriends: friends } RETURN { "name" : u.name, "titles" : rs } (compare with UNQL / JSONiq) www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 8. Use-Cases for script languages GET /user/fceller function (req, res) { var user = db.users.byExample({ username: req.urlParameters.username }); ... deal with unknown user... enrich result user.age = ... compute user age from birthday ...; delete user.hashedPassword; actions.resultOk(req, res, actions.HTTP_OK, user); hide info } www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 9. Use-Cases for script languages GET /user/fceller/eccentricity function (req, res) { var user = db.users.byExample({ username: req.urlParameters.username }); ... deal with unknown user... needs every node var eccentricity = ... compute eccentricity ...; actions.resultOk(req, res, actions.HTTP_OK, eccentricity); } www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 10. Use-Cases for script languages Transactions Triggers Predefined Objects for AJAX www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 11. MRuby Matz's embeddable minimal implementation of Ruby language www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 12. MRuby RiteVM as core Minimal standard libraries quotes from Matz Embeddable C API No perfect languages, even Ruby Like to provide choices www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 13. MRuby vs V8 JavaScript is a “complicated” language for embedding C++ class hierarchies V8 itself is complex (isolates, contexts, handle scopes), but fast mruby is plain and simple C code documentation is sketchy for both www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 14. MRuby vs V8 def fact n; (n > 1) ? n*fact(n-1) : 1; end mruby: 20 time-units V8: 0.6 time-units php: 20 time-units Ruby 1.9 (int): 9 time-units www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 15. Why use MRuby? “Like to provide choices” i.e. if you don‘t like prototype inheritance “still young” i.e. instead of using RiteVM, compile to machine code www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 16. MRuby and LLVM def fact n; (n > 1) ? n*fact(n-1) : 1; end 000 OP_ENTER 1:0:0:0:0:0:0 001 OP_MOVE R4 R1 002 OP_LOADI R5 1 003 OP_LOADNIL R6 004 OP_GT R4 '>' 1 005 OP_JMPNOT R4 017 006 OP_MOVE R4 R1 007 OP_LOADSELF R5 008 OP_MOVE R6 R1 009 OP_LOADI R7 1 010 OP_LOADNIL R8 011 OP_SUB R6 '-' 1 012 OP_LOADNIL R7 013 OP_SEND R5 'fact' 1 014 OP_LOADNIL R6 015 OP_MUL R4 '*' 1 016 OP_JMP 018 017 OP_LOADI R4 1 018 OP_RETURN R4 www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 17. MRuby and LLVM CASE(OP_SUB) { /* A B C R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/ int a = GETARG_A(i); /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): { mrb_int x, y, z; x = mrb_fixnum(regs[a]); y = mrb_fixnum(regs[a+1]); z = x - y; if (((x < 0) ^ (y < 0)) == 0 && (x < 0) != (z < 0)) { /* integer overflow */ SET_FLT_VALUE(regs[a], (mrb_float)x - (mrb_float)y); break; } SET_INT_VALUE(regs[a], z); } break; Simply replacing OP codes by machine code already gives a factor of 2 www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 18. Why use MRuby? If you have use-cases for scripts in ArangoDB (or any other database), mruby will eventually be an alternative Otherwise, use a language driver (aka Ashikawa for Ruby) and CRuby or JRuby www.arangodb.org (c) [email protected] Mittwoch, 14. November 12
- 19. Thank You! Stay in Touch: Fork me on github Google Group: ArangoDB Twitter: @fceller & @arangodb www.arangodb.org www.arangodb.org (c) [email protected] Mittwoch, 14. November 12