Hotcode 2013: Javascript in a database (Part 2)

1 like2,112 views

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.

Technology

RWTH Aachen, Computer Science Student on branch master
triAGENS GmbH, Developer
moonglum moonbeamlabs
by Lucas Dohmen
Creating APIs for Single Page Web Applications
ArangoDB Foxx
Samstag, 1. Juni 13

Single Page
Web Applications
Samstag, 1. Juni 13

The Idea
• What if we could talk to
the database directly?
• It would only need an API
• What if we could deﬁne
this API in JavaScript?
Samstag, 1. Juni 13

Single Page
Web Applications
This doesn‘t mean its a Rails/… Killer
Samstag, 1. Juni 13

What is ?
• Free and Open Source…
• … Document and Graph Store…
• … with embedded JavaScript…
• … and an amazing query language
Samstag, 1. Juni 13

/
(~(
) ) /_/
( _-----_(@ @)
( /
/|/--| V
" " " "
Samstag, 1. Juni 13

• An easy way to deﬁne REST APIs on top of
ArangoDB
• Tools for developing your single page web
application
Samstag, 1. Juni 13

Why another solution?
• ArangoDB Foxx is streamlined for API
creation – not a Jack of all trades
• It is designed for front end developers: Use
JavaScript, you already know that (without
running into callback hell *cough* Node.js)
Samstag, 1. Juni 13

FoxxApplication = require("org/arangodb/foxx").Application;
Samstag, 1. Juni 13

FoxxApplication = require("org/arangodb/foxx").Application;
app = new FoxxApplication();
Samstag, 1. Juni 13

FoxxApplication = require("org/arangodb/foxx").Application;
app = new FoxxApplication();
app.get("/users", function(req, res) {
});
Samstag, 1. Juni 13

FoxxApplication = require("org/arangodb/foxx").Application;
app = new FoxxApplication();
app.get("/users", function(req, res) {
});
res.set("Content-Type", "text/plain");
Samstag, 1. Juni 13

Parameterize
the routes
• You may want a route like `users/:id`…
• …and then access the value of `id` easily
Samstag, 1. Juni 13

FoxxApplication = require("org/arangodb/foxx").Application;
app = new FoxxApplication();
app.get("/users/:id", function(req, res) {
res.set("Content-Type", "text/plain");
});
app.start(applicationContext);
res.body = "Worked!";
Samstag, 1. Juni 13

• In your Foxx.Application you describe your
routes
• But your application can consist of multiple
Foxx.Applications
• … and you also want to deliver assets and
ﬁles
Manifest.json
Samstag, 1. Juni 13

${ "name": "my_website", "version": "1.2.1", "description": "My Website with a blog and a shop", "thumbnail": "images/website-logo.png", "apps": { "/blog": "apps/blog.js", "/shop": "apps/shop.js" }, "assets": { "application.js": { "files": [ "vendor/jquery.js", "assets/javascripts/*" ] } } } Samstag, 1. Juni 13$

More
• Deﬁne a setup and teardown function to
create and delete collections
• Deﬁne lib to set a base path for your require
statements
• Deﬁne ﬁles to deliver binary data unaltered
Samstag, 1. Juni 13

Documentation
as a ﬁrst class citizen
Samstag, 1. Juni 13

Annotate your Routes
• For Documentation
• But will later also be used for validation etc.
Samstag, 1. Juni 13

app.get("/users/:id", function(req, res) {
res.set("Content-Type", "text/plain");
res.body = "Your Wiese: " + req.params("id");
});
Samstag, 1. Juni 13

app.get("/users/:id", function(req, res) {
res.set("Content-Type", "text/plain");
res.body = "Your User: " + req.params("id");
});
Samstag, 1. Juni 13

app.get("/users/:id", function(req, res) {
res.set("Content-Type", "text/plain");
res.body = "Your User: " + req.params("id");
});
}).pathParam("id", {
description: "ID of the User",
dataType: "int"
Samstag, 1. Juni 13

Automatically generate
Swagger Docs
Samstag, 1. Juni 13

If you want to
learn about
• … how we use the Repository Pattern
• … how you can structure your Foxx App
Samstag, 1. Juni 13

Join us at our
workshop
tomorrow
11:00
DB Stage
Samstag, 1. Juni 13

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.

Rupy2012 ArangoDB Workshop Part1ArangoDB 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.

Building a spa_in_30minMichael Hackstein

The document presents ArangoDB Foxx, a framework for building single-page web applications that allows direct communication with the database using JavaScript. It emphasizes its streamlined API creation, eliminating server-client communication overhead and catering to front-end developers. The document also includes code snippets demonstrating the use of models and repositories within the Foxx framework.

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.

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.

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

CouchDB introductionSander van de Graaf

The document provides an overview of various database management systems, emphasizing schema-free document databases optimized for speed and distribution. It discusses different data models like key-value and document stores, along with examples including Amazon Dynamo and MongoDB. Additionally, the document highlights the implementation aspects and libraries available for various programming languages.

Intro To Mongo Dbchriskite

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.

The Lonesome LOD CloudRuben Verborgh

The document discusses the challenges and solutions associated with accessing linked data datasets via SPARQL and other methods, highlighting the need for more efficient client-side querying. It emphasizes the importance of high availability for endpoints and suggests a move towards intelligent clients rather than relying on complex server-side processing. Additionally, it proposes methods for analyzing client queries and improving user interaction with linked data fragments.

Query mechanisms for NoSQL databasesArangoDB Database

The document discusses query mechanisms for NoSQL databases. It begins by describing how relational databases require normalization of data into tables and use SQL for queries. NoSQL databases are introduced as being non-relational, schema-free, and having simple APIs. Document stores are highlighted as a type of NoSQL database that can natively store hierarchical data without normalization. Specific document stores like CouchDB and MongoDB are described, showing how data can be stored and queried in documents through HTTP requests or a mongo client. Map-reduce functions are also discussed as a way to perform complex queries across collections of documents.

Creating 3rd Generation Web APIs with HydraMarkus Lanthaler

The document discusses the challenges of creating third-generation web APIs using Hydra, emphasizing the issues of tightly coupled and brittle systems in API design. It presents a structured approach to API resources, utilizing hypermedia controls and linked data to enhance interaction. The content includes examples of resource representation and operations supported by Hydra, alongside a closing invitation for questions.

Developing CouchAppswesthoff

The document discusses developing and deploying CouchApps. It begins with an introduction to CouchDB as a document-based NoSQL database with a RESTful JSON API and built-in replication. CouchApps are then defined as applications built on CouchDB that use it as a data store, are stored within CouchDB, and served using the CouchDB HTTP server. Most CouchApps are written in JavaScript and use CouchDB features like storing files as document attachments, authentication, validation functions, and replication for deployment. Techniques for building CouchApps like these are then outlined.

N hidden gems in hippo forge and experience plugins (dec17)Woonsan Ko

The document discusses various plugins and tools available in the Hippo Forge ecosystem, particularly focusing on features that enhance content management systems (CMS). It highlights plugins such as the iframe perspective, folder context menus, external document pickers, document commenting, and content version utilities, each offering specific functionalities for improved content organization, collaboration, and version control. Additionally, it introduces the content HAL API for easier data consumption in applications and Spring Boot deploy support for cloud environments.

Introduction to couchdbiammutex

This document introduces CouchDB, a document-oriented NoSQL database that uses JSON documents with dynamic schemas. It can store complex data structures and scale horizontally. CouchDB uses a REST API and queries data through JavaScript MapReduce functions. The document demonstrates how to create and query a CouchDB database from Perl, including inserting documents, defining views, and retrieving view query results. Key features of CouchDB include its flexibility for various data types, replication, and ability to handle large amounts of data.

MongoDB 101Abhijeet Vaikar

MongoDB is a non-relational database that stores data in JSON-like documents with dynamic schemas. It features flexibility with JSON documents that map to programming languages, power through indexing and queries, and horizontal scaling. The document explains that MongoDB uses JSON and BSON formats to store data, has no fixed schema so fields can evolve freely, and demonstrates working with the mongo shell and RoboMongo GUI.

On Again; Off Again - Benjamin Young - ebookcraft 2017BookNet Canada

The document discusses the concept of offline-first web apps, highlighting the limitations of traditional online models and emphasizing the shifts in technology including web packaging and service workers. It elaborates on the need for portable web publications, which integrate features from both traditional e-books and modern web technologies. Key components include significant metadata, storage solutions, and potential use cases for enhancing user experience and security in web applications.

Introduction to MongoDBJustin Smestad

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.

Chapter4Fahad Sheref

This document provides an overview of XML, including: 1. XML is a meta markup language used to define languages for representing textual data and documents, not a replacement for HTML, programming language, or database. 2. XML allows defining applications ("markup languages") to represent text documents and data. Examples of uses include content management with XML documents in a database, data exchange between legacy systems, and representing metadata. 3. The document discusses XML terminology like tags, elements, attributes, namespaces, DTDs for defining element types, and XML schemas for more complex definitions than DTDs. It provides examples of using XML to represent relational data and a bibliographic format.

Querying Linked Data with SPARQL (2010)Olaf Hartig

This document provides an extensive tutorial on using SPARQL to query linked data on the web, discussing topics such as SPARQL endpoints, querying methods, result formats, and more. It covers the basics of issuing queries, accessing data from various sources, and advanced techniques like federated query processing and automated link traversal. Additionally, it highlights the importance of understanding data sources and the various libraries available for simplifying the querying process.

Fluentd - Unified logging layerTreasure Data, Inc.

Fluentd is an open source data collector that allows for flexible and extensible logging. It provides a unified way to collect logs, metrics, and events from various sources and send them to multiple destinations. It handles concerns like buffering, retries, and failover to provide reliable data transfer. Fluentd uses a plugin-based architecture so it can support many use cases like simple forwarding, lambda architectures, stream processing, and logging for Docker and Kubernetes.

JSONpedia - Facilitating consumption of MediaWiki contentMichele Mostarda

Jsonpedia is a Java library and REST service that retrieves and enriches MediaWiki content as JSON, allowing for various query types and storage solutions using Elasticsearch and MongoDB. Its features include an event-based parser, support for MediaWiki templates, and a web frontend for user interaction with REST services. Future enhancements include downloadable JSON dumps and RDF output capabilities.

Linked Data FragmentsRuben Verborgh

This document introduces Linked Data Fragments, which is an approach to querying Linked Data in a scalable and reliable way by moving intelligence from centralized servers to distributed clients. It describes how basic Linked Data Fragments can be used to answer SPARQL queries by retrieving and combining relevant fragments. The vision is for clients to be able to query different Linked Data sources across the web using various types of fragments. All Linked Data Fragments software is available as open source.

Web scraping 1 2-3 with python + scrapy (Summer BarCampHK 2012 version)Sammy Fung

Class.bluemix.dbaasRoss Tang

This document provides an overview of IBM's Bluemix DBaaS SQL Database service. It offers a fully managed SQL database service powered by DB2. The service provides automatic backups, high availability, data encryption and masking capabilities. It also integrates with other Bluemix services like DataWorks, Cloudant and dashDB and provides sensitive data reporting capabilities suitable for PCI audits.

Getting Started with the Alma APIKyle Banerjee

The document provides an overview of using the Alma API for managing various library records, including user, item, and holdings modifications. It emphasizes the use of command-line tools like curl and xmlstarlet for interacting with the API and automation through scripting. Additionally, it offers guidance on getting started with command line usage and includes practical examples for extracting and updating records within Alma’s system.

Why we love ArangoDB. The hunt for the right NosQL DatabaseAndreas Jung

The document discusses the advantages of NoSQL databases compared to traditional relational databases, emphasizing their flexibility and suitability for various use cases. It explores different categories of NoSQL databases, challenges posed by cloud computing and big data, and the implications of the CAP theorem. Additionally, it highlights the author's search for a multifunctional NoSQL solution with a focus on ArangoDB, detailing its features, capabilities, and community support.

Markup As An ApiJean-Jacques Halans

This document discusses the evolution of markup languages and semantic technologies on the web. It covers HTML, XML, RDF, OWL, microformats, CSS, HTML5, structured blogging, and client-side inclusion techniques like HInclude and Purple-Include. The overarching goals are to publish content once and share it across different formats and devices, add more semantic meaning that can be interpreted by machines, and create structured information like reviews and events that can be syndicated.

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.

Hotcode 2013: Javascript in a database (Part 1)ArangoDB Database

More Related Content

What's hot (20)

Intro To Mongo Dbchriskite

The Lonesome LOD CloudRuben Verborgh

Query mechanisms for NoSQL databasesArangoDB Database

Creating 3rd Generation Web APIs with HydraMarkus Lanthaler

Developing CouchAppswesthoff

N hidden gems in hippo forge and experience plugins (dec17)Woonsan Ko

Introduction to couchdbiammutex

MongoDB 101Abhijeet Vaikar

On Again; Off Again - Benjamin Young - ebookcraft 2017BookNet Canada

Introduction to MongoDBJustin Smestad

Chapter4Fahad Sheref

Querying Linked Data with SPARQL (2010)Olaf Hartig

Fluentd - Unified logging layerTreasure Data, Inc.

JSONpedia - Facilitating consumption of MediaWiki contentMichele Mostarda

Linked Data FragmentsRuben Verborgh

Web scraping 1 2-3 with python + scrapy (Summer BarCampHK 2012 version)Sammy Fung

Class.bluemix.dbaasRoss Tang

Getting Started with the Alma APIKyle Banerjee

Why we love ArangoDB. The hunt for the right NosQL DatabaseAndreas Jung

Markup As An ApiJean-Jacques Halans

Intro To Mongo Dbchriskite

The Lonesome LOD CloudRuben Verborgh

Query mechanisms for NoSQL databasesArangoDB Database

Creating 3rd Generation Web APIs with HydraMarkus Lanthaler

Developing CouchAppswesthoff

N hidden gems in hippo forge and experience plugins (dec17)Woonsan Ko

Introduction to couchdbiammutex

MongoDB 101Abhijeet Vaikar

On Again; Off Again - Benjamin Young - ebookcraft 2017BookNet Canada

Introduction to MongoDBJustin Smestad

Chapter4Fahad Sheref

Querying Linked Data with SPARQL (2010)Olaf Hartig

Fluentd - Unified logging layerTreasure Data, Inc.

JSONpedia - Facilitating consumption of MediaWiki contentMichele Mostarda

Linked Data FragmentsRuben Verborgh

Web scraping 1 2-3 with python + scrapy (Summer BarCampHK 2012 version)Sammy Fung

Class.bluemix.dbaasRoss Tang

Getting Started with the Alma APIKyle Banerjee

Why we love ArangoDB. The hunt for the right NosQL DatabaseAndreas Jung

Markup As An ApiJean-Jacques Halans

Viewers also liked (20)

GraphDatabases and what we can use them forMichael Hackstein

Hotcode 2013: Javascript in a database (Part 1)ArangoDB 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.

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.

Running MRuby in a Database - ArangoDB - RuPy 2012 ArangoDB Database

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.

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.

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 & 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-ModelosHelder Santana

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-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...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...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 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 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 @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 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 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 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.

ArangoDBArangoDB Database

GraphDatabases and what we can use them forMichael Hackstein

Hotcode 2013: Javascript in a database (Part 1)ArangoDB Database

Complex queries in a distributed multi-model databaseMax Neunhöffer

Backbone using Extensible Database APIs over HTTPMax Neunhöffer

Running MRuby in a Database - ArangoDB - RuPy 2012 ArangoDB Database

Multi-model databases and node.jsMax Neunhöffer

Extensible Database APIs and their role in Software ArchitectureMax Neunhöffer

Domain Driven Design & NoSQLArangoDB Database

ArangoDB – Persistência Poliglota e Banco de Dados Multi-ModelosHelder Santana

Domain Driven Design & NoSQLArangoDB Database

Multi model-databasesArangoDB Database

Jan Steemann: Modelling data in a schema free world (Talk held at Froscon, 2...ArangoDB Database

Processing large-scale graphs with Google(TM) Pregel by MICHAEL HACKSTEIN at...Big Data Spain

Overhauling a database engine in 2 monthsMax Neunhöffer

guacamole: an Object Document Mapper for ArangoDBMax Neunhöffer

Domain driven design @FrOSConArangoDB Database

Processing large-scale graphs with Google PregelMax Neunhöffer

Wir sind aber nicht TwitterArangoDB Database

Domain Driven Design and NoSQL TLVArangoDB Database

ArangoDBArangoDB Database

Similar to Hotcode 2013: Javascript in a database (Part 2) (20)

Working Towards RESTful Web Serviesjzehavi

The document discusses building RESTful web services and APIs. It provides examples of CRUD operations like GET, POST, PUT, DELETE on a project resource using JSON representations and appropriate HTTP response codes. It covers REST principles like identifying resources with URLs, manipulating resources through representations, self-descriptive messaging, and including hypermedia links in responses. The document advises implementing common standards, consuming your own API for testing, and considering features like authentication, rate limiting and versioning for APIs intended for public use.

One Page, One App -or- How to Write a Crawlable Single Page Web Apptechnicolorenvy

This document discusses writing crawlable single page web applications. It describes using a client-server model where the server renders views for crawlers. This allows for good search engine optimization while keeping the benefits of a single page app like native-like experiences. Various frameworks that support this approach like Meteor, Derby and Rendr are described. Rendr is highlighted as an option that uses Backbone on the client with Express on the server, allowing APIs to be customized, though it is missing features common in frameworks. The direction of making Rendr's modules smaller and lazy loading views is suggested.

Lightweight javaEE with GuicePeerapat Asoktummarungsri

NoSQL Now 2013 PresentationArjen Schoneveld

The document discusses the transition of the Sportlink sports ERP system to a service-oriented architecture using MongoDB for improved scalability and flexibility. It emphasizes the benefits of using a schema-less NoSQL database, like MongoDB, for handling various sports management applications, such as digital match reports. Key concepts include the integration of Navajo services with MongoDB for seamless data processing and service communication.

Introduction to node.js by Ran Mizrahi @ Reversim SummitRan Mizrahi

The document is an introduction to Node.js, detailing its features as a server-side JavaScript platform designed for scalable, non-blocking I/O applications. It highlights the comparison between Apache and Nginx web servers, emphasizing the advantages of Node.js with its event-driven architecture. Additionally, it discusses popular frameworks and tools within the Node.js ecosystem, such as npm, Express, Socket.io, and Mongoose.

How we're building WerckerMicha Hernandez van Leuffen

The document discusses the technology stack used to build the Wercker platform for continuous deployment. It focuses on key Node.js modules like Express for building APIs, Async for managing asynchronous code, Request for making HTTP requests, and Mongoose for interacting with MongoDB. Examples are provided for how each module is used. Other technologies mentioned include Backbone.js, WebSockets, nodeenv, socket.io, aws2js, and underscore.js.

APEX Alpe Adria 2019 - JavaScript in APEX - do it right!Marko Gorički

Marko Gorički's presentation focuses on effectively using JavaScript in Oracle APEX, emphasizing the need for dynamic actions and external JavaScript files to enhance maintainability and performance. Key points include avoiding inline JavaScript to reduce page size and improve debugging, as well as organizing code using JavaScript namespaces. The presentation also advocates for documenting code with JSDoc and employing a hybrid approach to JavaScript usage in APEX applications.

Linked data based semantic annotation using Drupal and Apache StanbolGabriel Dragomir

The document discusses the integration of Apache Stanbol with Drupal for semantic annotation and linked data management, emphasizing the importance of organizing and analyzing large volumes of unstructured data. It highlights the capabilities of Stanbol, including its modular architecture and service-oriented integration, enabling processes such as metadata extraction and entity recognition. The document also outlines the practical use of Stanbol within Drupal, showcasing how to use RDF for data transport and semantic enrichment of content.

DIY Synthetic: Private WebPagetest MagicJonathan Klein

The document discusses using WebPagetest for private synthetic monitoring. It describes configuring WebPagetest tests using a JSON configuration file to run on a schedule. Test results are sent to Graphite for visualization and Splunk for logging. Advanced features like scripted prepending and multi-page flows are covered. Using WebPagetest is compared to paid tools, and future work like improving the testing process is proposed.

APIDays 2018 - API Development Lifecycle - The secret ingredient behind RESTf...FABERNOVEL TECHNOLOGIES

The document discusses the challenges of ensuring API specifications match responses, which can lead to application crashes. It highlights the need for better documentation and testing tools, and explores the use of JSON schema to create a single source of truth for API specifications. The conclusion underscores the importance of maintaining updated specs to improve efficiency for customers, project managers, and developers.

Lone StarPHP 2013 - Building Web Apps from a New AnglePablo Godel

The document is a presentation by Pablo Godel discussing the development of web applications using AngularJS, highlighting its features such as MVC architecture, data binding, and directives. It also covers topics on web hosting, open source contributions, and the integration of AngularJS with back-end technologies like Symfony and Silex. Additionally, Godel shares resources and tools for developers to enhance their AngularJS applications.

Webapplikationen mit Backbone.jsSebastian Springer

The document outlines the structure and implementation of a film database single page application using RequireJS, Backbone.js, and Bootstrap. It describes setting up the application framework with RequireJS as the module loader, defining models, collections, views, and routers with Backbone.js. It also covers templating views with Underscore templates, and handling CRUD operations to retrieve, create, update and delete film data from the server.

Enterprise Maven Repository BOFMax Andersen

The document discusses the JBoss Enterprise Maven Repository, detailing its purpose as a central directory for various artifacts used in enterprise middleware projects. It highlights the Maven repository's structure, including the importance of unique group-artifact-version identifiers, dependency management, and the use of BOM POMs for project stacks. Additionally, it provides instructions on accessing and utilizing the repository effectively, along with various tools and resources available for developers.

Intro to Ember.jsJay Phelps

실시간 웹 협업도구 만들기 V0.3NAVER D2

The document discusses building a real-time collaborative web tool using operational transformation (OT). OT allows multiple users to collaboratively edit a document by transforming and replicating document operations across clients. The basic concepts covered include the data model, operation model, and OT functions. OT works by having each client execute operations, transmit operations to other clients, and transform operations so that all clients remain in sync despite simultaneous edits. This replicated architecture and use of OT functions helps enable real-time shared editing of documents.

Drupal and Apache Stanbol. What if you could reliably do autotagging?Gabriel Dragomir

The document discusses Apache Stanbol, an open source software stack that can extract semantic data from documents. It describes how Stanbol uses semantic analysis and natural language processing to automatically tag and enrich content with entities, citations and related information. The document also explains how Stanbol can be integrated with Drupal to enable features like automatic tagging, dynamic annotation and autocompletion through a REST API that returns JSON-LD.

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.

Experiments in Data Portability 2Glenn Jones

The document discusses experiments in data portability, highlighting interoperability between users, developers, and vendors in social media utilities. It outlines various concepts such as profile importing, social graph discovery, and the use of open standards to improve user experience while acknowledging the complexities of data ownership and its transient nature. The document emphasizes the value of integrating multiple data sources to enhance applications, ultimately advocating for a more user-centric approach to data management.

Troubleshooting Live Java Web Applicationsashleypuls

The document discusses troubleshooting live Java web applications, emphasizing systematic approaches to identify and resolve issues. It introduces tools for monitoring application performance, gathering statistics, and investigating problems, highlighting tools like New Relic and YourKit. It also covers user feedback about performance issues and techniques to profile and monitor Java applications.

Tools Of The Geospatial WebMichael Maclennan

Working Towards RESTful Web Serviesjzehavi

One Page, One App -or- How to Write a Crawlable Single Page Web Apptechnicolorenvy

Lightweight javaEE with GuicePeerapat Asoktummarungsri

NoSQL Now 2013 PresentationArjen Schoneveld

Introduction to node.js by Ran Mizrahi @ Reversim SummitRan Mizrahi

How we're building WerckerMicha Hernandez van Leuffen

APEX Alpe Adria 2019 - JavaScript in APEX - do it right!Marko Gorički

Linked data based semantic annotation using Drupal and Apache StanbolGabriel Dragomir

DIY Synthetic: Private WebPagetest MagicJonathan Klein

APIDays 2018 - API Development Lifecycle - The secret ingredient behind RESTf...FABERNOVEL TECHNOLOGIES

Lone StarPHP 2013 - Building Web Apps from a New AnglePablo Godel

Webapplikationen mit Backbone.jsSebastian Springer

Enterprise Maven Repository BOFMax Andersen

Intro to Ember.jsJay Phelps

실시간 웹 협업도구 만들기 V0.3NAVER D2

Drupal and Apache Stanbol. What if you could reliably do autotagging?Gabriel Dragomir

FOXX - a Javascript application framework on top of ArangoDBArangoDB Database

Experiments in Data Portability 2Glenn Jones

Troubleshooting Live Java Web Applicationsashleypuls

Tools Of The Geospatial WebMichael Maclennan

More from ArangoDB Database (20)

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/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/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 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 #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 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 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 OasisArangoDB Database

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 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.

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.

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 MetadataArangoDB Database

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 OasisArangoDB Database

ArangoDB 3.5 Feature Overview Webinar - Sept 12, 2019ArangoDB Database

3.5 webinar ArangoDB Database

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 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 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.

ATO 2022 - Machine Learning + Graph Databases for Better Recommendations (3)....ArangoDB Database

Machine Learning + Graph Databases for Better Recommendations V2 08/20/2022ArangoDB Database

Machine Learning + Graph Databases for Better Recommendations V1 08/06/2022ArangoDB Database

ArangoDB 3.9 - Further Powering Graphs at ScaleArangoDB Database

GraphSage vs Pinsage #InsideArangoDBArangoDB Database

Webinar: ArangoDB 3.8 Preview - Analytics at Scale ArangoDB Database

Graph Analytics with ArangoDBArangoDB Database

Getting Started with ArangoDB OasisArangoDB Database

Custom Pregel Algorithms in ArangoDBArangoDB Database

Hacktoberfest 2020 - Intro to Knowledge GraphsArangoDB Database

A Graph Database That Scales - ArangoDB 3.7 Release WebinarArangoDB Database

gVisor, Kata Containers, Firecracker, Docker: Who is Who in the Container Space?ArangoDB Database

ArangoML Pipeline Cloud - Managed Machine Learning MetadataArangoDB Database

ArangoDB 3.7 Roadmap: Performance at ScaleArangoDB Database

Webinar: What to expect from ArangoDB OasisArangoDB Database

ArangoDB 3.5 Feature Overview Webinar - Sept 12, 2019ArangoDB Database

3.5 webinar ArangoDB Database

Webinar: How native multi model works in ArangoDBArangoDB Database

An introduction to multi-model databasesArangoDB Database

Running complex data queries in a distributed systemArangoDB Database

Recently uploaded (20)

Lessons Learned from Developing Secure AI Workflows.pdfPriyanka Aash

You are not excused! How to avoid security blind spots on the way to productionMichele Leroux Bustamante

We live in an ever evolving landscape for cyber threats creating security risk for your production systems. Mitigating these risks requires participation throughout all stages from development through production delivery - and by every role including architects, developers QA and DevOps engineers, product owners and leadership. No one is excused! This session will cover examples of common mistakes or missed opportunities that can lead to vulnerabilities in production - and ways to do better throughout the development lifecycle.

Connecting Data and Intelligence: The Role of FME in Machine LearningSafe Software

In this presentation, we want to explore powerful data integration and preparation for Machine Learning. FME is known for its ability to manipulate and transform geospatial data, connecting diverse data sources into efficient and automated workflows. By integrating FME with Machine Learning techniques, it is possible to transform raw data into valuable insights faster and more accurately, enabling intelligent analysis and data-driven decision making.

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.

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!

The Future of Product Management in AI ERA.pdfAlyona Owens

Hi, I’m Aly Owens, I have a special pleasure to stand here as over a decade ago I graduated from CityU as an international student with an MBA program. I enjoyed the diversity of the school, ability to work and study, the network that came with being here, and of course the price tag for students here has always been more affordable than most around. Since then I have worked for major corporations like T-Mobile and Microsoft and many more, and I have founded a startup. I've also been teaching product management to ensure my students save time and money to get to the same level as me faster avoiding popular mistakes. Today as I’ve transitioned to teaching and focusing on the startup, I hear everybody being concerned about Ai stealing their jobs… We’ll talk about it shortly. But before that, I want to take you back to 1997. One of my favorite movies is “Fifth Element”. It wowed me with futuristic predictions when I was a kid and I’m impressed by the number of these predictions that have already come true. Self-driving cars, video calls and smart TV, personalized ads and identity scanning. Sci-fi movies and books gave us many ideas and some are being implemented as we speak. But we often get ahead of ourselves: Flying cars,Colonized planets, Human-like AI: not yet, Time travel, Mind-machine neural interfaces for everyone: Only in experimental stages (e.g. Neuralink). Cyberpunk dystopias: Some vibes (neon signs + inequality + surveillance), but not total dystopia (thankfully). On the bright side, we predict that the working hours should drop as Ai becomes our helper and there shouldn’t be a need to work 8 hours/day. Nobody knows for sure but we can require that from legislation. Instead of waiting to see what the government and billionaires come up with, I say we should design our own future. So, we as humans, when we don’t know something - fear takes over. The same thing happened during the industrial revolution. In the Industrial Era, machines didn’t steal jobs—they transformed them but people were scared about their jobs. The AI era is making similar changes except it feels like robots will take the center stage instead of a human. First off, even when it comes to the hottest space in the military - drones, Ai does a fraction of work. AI algorithms enable real-time decision-making, obstacle avoidance, and mission optimization making drones far more autonomous and capable than traditional remote-controlled aircraft. Key technologies include computer vision for object detection, GPS-enhanced navigation, and neural networks for learning and adaptation. But guess what? There are only 2 companies right now that utilize Ai in drones to make autonomous decisions - Skydio and DJI.

" 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.

Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdfcaoyixuan2019

Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdfPriyanka Aash

Cyber Defense Matrix Workshop - RSA ConferencePriyanka Aash

2025_06_18 - OpenMetadata Community Meeting.pdfOpenMetadata

The community meetup was held Wednesday June 18, 2025 @ 9:00 AM PST. Catch the next OpenMetadata Community Meetup @ https://www.meetup.com/openmetadata-meetup-group/ In this month's OpenMetadata Community Meetup, "Enforcing Quality & SLAs with OpenMetadata Data Contracts," we covered data contracts, why they matter, and how to implement them in OpenMetadata to increase the quality of your data assets! Agenda Highlights: 👋 Introducing Data Contracts: An agreement between data producers and consumers 📝 Data Contracts key components: Understanding a contract and its purpose 🧑‍🎨 Writing your first contract: How to create your own contracts in OpenMetadata 🦾 An OpenMetadata MCP Server update! ➕ And More!

Techniques for Automatic Device Identification and Network Assignment.pdfPriyanka Aash

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...Josef Weingand

"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...Fwdays

GenAI Opportunities and Challenges - Where 370 Enterprises Are Focusing Now.pdfPriyanka Aash

AI vs Human Writing: Can You Tell the Difference?Shashi Sathyanarayana, Ph.D

Cluster-Based Multi-Objective Metamorphic Test Case Pair Selection for Deep N...janeliewang985

Coordinated Disclosure for ML - What's Different and What's the Same.pdfPriyanka Aash

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.

Lessons Learned from Developing Secure AI Workflows.pdfPriyanka Aash

You are not excused! How to avoid security blind spots on the way to productionMichele Leroux Bustamante

Connecting Data and Intelligence: The Role of FME in Machine LearningSafe Software

9-1-1 Addressing: End-to-End Automation Using FMESafe Software

From Manual to Auto Searching- FME in the Driver's SeatSafe Software

The Future of Product Management in AI ERA.pdfAlyona Owens

" How to survive with 1 billion vectors and not sell a kidney: our low-cost c...Fwdays

Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdfcaoyixuan2019

Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdfPriyanka Aash

Cyber Defense Matrix Workshop - RSA ConferencePriyanka Aash

2025_06_18 - OpenMetadata Community Meeting.pdfOpenMetadata

Techniques for Automatic Device Identification and Network Assignment.pdfPriyanka Aash

Security Tips for Enterprise Azure SolutionsMichele Leroux Bustamante

Wenn alles versagt - IBM Tape schützt, was zählt! Und besonders mit dem neust...Josef Weingand

"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...Fwdays

GenAI Opportunities and Challenges - Where 370 Enterprises Are Focusing Now.pdfPriyanka Aash

AI vs Human Writing: Can You Tell the Difference?Shashi Sathyanarayana, Ph.D

Cluster-Based Multi-Objective Metamorphic Test Case Pair Selection for Deep N...janeliewang985

Coordinated Disclosure for ML - What's Different and What's the Same.pdfPriyanka Aash

OpenPOWER Foundation & Open-Source Core InnovationsIBM

Hotcode 2013: Javascript in a database (Part 2)

1. RWTH Aachen, Computer Science Student on branch master triAGENS GmbH, Developer moonglum moonbeamlabs by Lucas Dohmen Creating APIs for Single Page Web Applications ArangoDB Foxx Samstag, 1. Juni 13

2. Single Page Web Applications Samstag, 1. Juni 13

3. The Idea • What if we could talk to the database directly? • It would only need an API • What if we could deﬁne this API in JavaScript? Samstag, 1. Juni 13

4. Single Page Web Applications Samstag, 1. Juni 13

5. Single Page Web Applications This doesn‘t mean its a Rails/… Killer Samstag, 1. Juni 13

6. What is ? • Free and Open Source… • … Document and Graph Store… • … with embedded JavaScript… • … and an amazing query language Samstag, 1. Juni 13

7. Samstag, 1. Juni 13

8. / (~( ) ) /_/ ( _-----_(@ @) ( / /|/--| V " " " " Samstag, 1. Juni 13

9. • An easy way to deﬁne REST APIs on top of ArangoDB • Tools for developing your single page web application Samstag, 1. Juni 13

10. Why another solution? • ArangoDB Foxx is streamlined for API creation – not a Jack of all trades • It is designed for front end developers: Use JavaScript, you already know that (without running into callback hell *cough* Node.js) Samstag, 1. Juni 13

11. Foxx.Application Samstag, 1. Juni 13

12. Samstag, 1. Juni 13

13. FoxxApplication = require("org/arangodb/foxx").Application; Samstag, 1. Juni 13

14. FoxxApplication = require("org/arangodb/foxx").Application; Samstag, 1. Juni 13

15. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); Samstag, 1. Juni 13

16. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); Samstag, 1. Juni 13

17. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { }); Samstag, 1. Juni 13

18. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { }); Samstag, 1. Juni 13

19. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { }); res.set("Content-Type", "text/plain"); Samstag, 1. Juni 13

20. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { }); res.set("Content-Type", "text/plain"); Samstag, 1. Juni 13

21. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { }); res.set("Content-Type", "text/plain"); res.body = "Worked!"; Samstag, 1. Juni 13

22. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { res.set("Content-Type", "text/plain"); }); res.body = "Worked!"; Samstag, 1. Juni 13

23. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { res.set("Content-Type", "text/plain"); }); app.start(applicationContext); res.body = "Worked!"; Samstag, 1. Juni 13

24. Parameterize the routes • You may want a route like `users/:id`… • …and then access the value of `id` easily Samstag, 1. Juni 13

25. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users", function(req, res) { res.set("Content-Type", "text/plain"); }); app.start(applicationContext); res.body = "Worked!"; Samstag, 1. Juni 13

26. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users ", function(req, res) { res.set("Content-Type", "text/plain"); }); app.start(applicationContext); res.body = "Worked!"; Samstag, 1. Juni 13

27. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); }); app.start(applicationContext); res.body = "Worked!"; Samstag, 1. Juni 13

28. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); }); app.start(applicationContext); res.body = "Worked!"; Samstag, 1. Juni 13

29. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); res.body = "Your User: " + req.params("id"); }); app.start(applicationContext); Samstag, 1. Juni 13

30. • In your Foxx.Application you describe your routes • But your application can consist of multiple Foxx.Applications • … and you also want to deliver assets and ﬁles Manifest.json Samstag, 1. Juni 13

31. { "name": "my_website", "version": "1.2.1", "description": "My Website with a blog and a shop", "thumbnail": "images/website-logo.png", "apps": { "/blog": "apps/blog.js", "/shop": "apps/shop.js" }, "assets": { "application.js": { "files": [ "vendor/jquery.js", "assets/javascripts/*" ] } } } Samstag, 1. Juni 13

32. { "name": "my_website", "version": "1.2.1", "description": "My Website with a blog and a shop", "thumbnail": "images/website-logo.png", "apps": { "/blog": "apps/blog.js", "/shop": "apps/shop.js" }, "assets": { "application.js": { "files": [ "vendor/jquery.js", "assets/javascripts/*" ] } } } Samstag, 1. Juni 13

33. { "name": "my_website", "version": "1.2.1", "description": "My Website with a blog and a shop", "thumbnail": "images/website-logo.png", "apps": { "/blog": "apps/blog.js", "/shop": "apps/shop.js" }, "assets": { "application.js": { "files": [ "vendor/jquery.js", "assets/javascripts/*" ] } } } Samstag, 1. Juni 13

34. More • Define a setup and teardown function to create and delete collections • Define lib to set a base path for your require statements • Define files to deliver binary data unaltered Samstag, 1. Juni 13

35. Documentation as a ﬁrst class citizen Samstag, 1. Juni 13

36. Annotate your Routes • For Documentation • But will later also be used for validation etc. Samstag, 1. Juni 13

37. FoxxApplication = require("org/arangodb/foxx").Application; app = new FoxxApplication(); app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); res.body = "Your Wiese: " + req.params("id"); }); app.start(applicationContext); Samstag, 1. Juni 13

38. app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); res.body = "Your Wiese: " + req.params("id"); }); Samstag, 1. Juni 13

39. app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); res.body = "Your User: " + req.params("id"); }); Samstag, 1. Juni 13

40. app.get("/users/:id", function(req, res) { res.set("Content-Type", "text/plain"); res.body = "Your User: " + req.params("id"); }); }).pathParam("id", { description: "ID of the User", dataType: "int" Samstag, 1. Juni 13

41. Automatically generate Swagger Docs Samstag, 1. Juni 13

42. If you want to learn about • … how we use the Repository Pattern • … how you can structure your Foxx App Samstag, 1. Juni 13

43. Join us at our workshop tomorrow 11:00 DB Stage Samstag, 1. Juni 13

Hotcode 2013: Javascript in a database (Part 2)

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Hotcode 2013: Javascript in a database (Part 2) (20)

More from ArangoDB Database (20)

Recently uploaded (20)

Hotcode 2013: Javascript in a database (Part 2)