A graph is a structure composed of a set of vertices (i.e.~nodes, dots) connected to one another by a set of edges (i.e.~links, lines). The concept of a graph has been around since the late 19th century, however, only in recent decades has there been a strong resurgence in the development of both graph theories and applications. In applied computing, since the late 1960s, the interlinked table structure of the relational database has been the predominant information storage and retrieval paradigm. With the growth of graph/network-based data and the need to efficiently process such data, new data management systems have been developed. In contrast to the index-intensive, set-theoretic operations of relational databases, graph databases make use of index-free traversals. This presentation will discuss the graph traversal programming pattern and its application to problem-solving with graph databases.
These webinar slides are an introduction to Neo4j and Graph Databases. They discuss the primary use cases for Graph Databases and the properties of Neo4j which make those use cases possible. They also cover the high-level steps of modeling, importing, and querying your data using Cypher and touch on RDBMS to Graph.
026 Neo4j Data Loading (ETL_ELT) Best Practices - NODES2022 AMERICAS Advanced...Neo4j
What patterns are most appropriate for building ETLs using Neo4j? In this session, we share how we built the Google Cloud DataFlow flex template using the Neo4j Java API. You can then apply the same approach to building read and write operators in any framework, including AWS Lambda and Google Cloud Functions.
ksqlDB: A Stream-Relational Database Systemconfluent
Speaker: Matthias J. Sax, Software Engineer, Confluent
ksqlDB is a distributed event streaming database system that allows users to express SQL queries over relational tables and event streams. The project was released by Confluent in 2017 and is hosted on Github and developed with an open-source spirit. ksqlDB is built on top of Apache Kafka®, a distributed event streaming platform. In this talk, we discuss ksqlDB’s architecture that is influenced by Apache Kafka and its stream processing library, Kafka Streams. We explain how ksqlDB executes continuous queries while achieving fault tolerance and high vailability. Furthermore, we explore ksqlDB’s streaming SQL dialect and the different types of supported queries.
Matthias J. Sax is a software engineer at Confluent working on ksqlDB. He mainly contributes to Kafka Streams, Apache Kafka's stream processing library, which serves as ksqlDB's execution engine. Furthermore, he helps evolve ksqlDB's "streaming SQL" language. In the past, Matthias also contributed to Apache Flink and Apache Storm and he is an Apache committer and PMC member. Matthias holds a Ph.D. from Humboldt University of Berlin, where he studied distributed data stream processing systems.
https://db.cs.cmu.edu/events/quarantine-db-talk-2020-confluent-ksqldb-a-stream-relational-database-system/
Geospatial Advancements in ElasticsearchElasticsearch
Geospatial data structures in Elasticsearch and Apache Lucene have been evolving and improving at a rapid pace. Learn how Elastic has simplified the geospatial indexing, search, and analytics use case by advancing the state of geo in Apache Lucene and Elasticsearch. From new spatial indexing strategies and performance improvements in Lucene to changes in geospatial field mappings in Elasticsearch, take a journey through the world of spatial and multi-dimensional indexing and search in the Elastic Stack.
These webinar slides are an introduction to Neo4j and Graph Databases. They discuss the primary use cases for Graph Databases and the properties of Neo4j which make those use cases possible. They also cover the high-level steps of modeling, importing, and querying your data using Cypher and touch on RDBMS to Graph.
026 Neo4j Data Loading (ETL_ELT) Best Practices - NODES2022 AMERICAS Advanced...Neo4j
What patterns are most appropriate for building ETLs using Neo4j? In this session, we share how we built the Google Cloud DataFlow flex template using the Neo4j Java API. You can then apply the same approach to building read and write operators in any framework, including AWS Lambda and Google Cloud Functions.
ksqlDB: A Stream-Relational Database Systemconfluent
Speaker: Matthias J. Sax, Software Engineer, Confluent
ksqlDB is a distributed event streaming database system that allows users to express SQL queries over relational tables and event streams. The project was released by Confluent in 2017 and is hosted on Github and developed with an open-source spirit. ksqlDB is built on top of Apache Kafka®, a distributed event streaming platform. In this talk, we discuss ksqlDB’s architecture that is influenced by Apache Kafka and its stream processing library, Kafka Streams. We explain how ksqlDB executes continuous queries while achieving fault tolerance and high vailability. Furthermore, we explore ksqlDB’s streaming SQL dialect and the different types of supported queries.
Matthias J. Sax is a software engineer at Confluent working on ksqlDB. He mainly contributes to Kafka Streams, Apache Kafka's stream processing library, which serves as ksqlDB's execution engine. Furthermore, he helps evolve ksqlDB's "streaming SQL" language. In the past, Matthias also contributed to Apache Flink and Apache Storm and he is an Apache committer and PMC member. Matthias holds a Ph.D. from Humboldt University of Berlin, where he studied distributed data stream processing systems.
https://db.cs.cmu.edu/events/quarantine-db-talk-2020-confluent-ksqldb-a-stream-relational-database-system/
Geospatial Advancements in ElasticsearchElasticsearch
Geospatial data structures in Elasticsearch and Apache Lucene have been evolving and improving at a rapid pace. Learn how Elastic has simplified the geospatial indexing, search, and analytics use case by advancing the state of geo in Apache Lucene and Elasticsearch. From new spatial indexing strategies and performance improvements in Lucene to changes in geospatial field mappings in Elasticsearch, take a journey through the world of spatial and multi-dimensional indexing and search in the Elastic Stack.
Maps and Meaning: Graph-based Entity Resolution in Apache Spark & GraphXDatabricks
Data integration and the automation of tedious data extraction tasks are the fundamental building blocks of a data-driven organizations and are overlooked or underestimated at times. Aside from data extraction, scraping and ETL tasks, entity resolution is a crucial step in successfully combining datasets. The combination of data sources is usually what provides richness in features and variance. Building an expertise in entity resolution is important for data engineerings to successfully combine data sources. Graph-based entity resolution algorithms have emerged as a highly effective approach.
This talk will present the implementation of a graph-bases entity resolution technique in GraphX and in GraphFrames respectively. Working from concept, through how to implement the algorithm in Spark, the technique will also be illustrated by walking through a practical example. The technique will exhibit an example where efficacy can be achieved based on simple heuristics, and at the same time map a path to a machine-learning assisted entity resolution engine with a powerful knowledge graph at its center.
The role of ML can be found upstream in building the graph, for example by using classification algorithms in determining the link strength between nodes based on data, or downstream where dimensionality reduction can play a role in clustering and reduce the computational load in the resolution stage. The audience will leave with a clear picture of a scalable data pipeline performing entity resolution effectively and a thorough understanding of the internal mechanism, ready to apply it to their use cases.
Review the latest features released in Neo4j version 4.1 including Cypher, database drivers, clustering, security, and extension libraries like APOC and Spring Data Neo4j!
Video of the presentation can be seen here: https://www.youtube.com/watch?v=uxuLRiNoDio
The Data Source API in Spark is a convenient feature that enables developers to write libraries to connect to data stored in various sources with Spark. Equipped with the Data Source API, users can load/save data from/to different data formats and systems with minimal setup and configuration. In this talk, we introduce the Data Source API and the unified load/save functions built on top of it. Then, we show examples to demonstrate how to build a data source library.
Building Cloud-Native App Series - Part 4 of 11
Microservices Architecture Series
NoSQL vs SQL
Redis, MongoDB, AWS DynamoDB
Big Data Design Patterns
Sharding, Partitions
ksqlDB is a stream processing SQL engine, which allows stream processing on top of Apache Kafka. ksqlDB is based on Kafka Stream and provides capabilities for consuming messages from Kafka, analysing these messages in near-realtime with a SQL like language and produce results again to a Kafka topic. By that, no single line of Java code has to be written and you can reuse your SQL knowhow. This lowers the bar for starting with stream processing significantly.
ksqlDB offers powerful capabilities of stream processing, such as joins, aggregations, time windows and support for event time. In this talk I will present how KSQL integrates with the Kafka ecosystem and demonstrate how easy it is to implement a solution using ksqlDB for most part. This will be done in a live demo on a fictitious IoT sample.
Transforming AI with Graphs: Real World Examples using Spark and Neo4jDatabricks
Graphs – or information about the relationships, connection, and topology of data points – are transforming machine learning. We’ll walk through real world examples of how to get transform your tabular data into a graph and how to get started with graph AI. This talk will provide an overview of how we to incorporate graph based features into traditional machine learning pipelines, create graph embeddings to better describe your graph topology, and give you a preview of approaches for graph native learning using graph neural networks. We’ll talk about relevant, real world case studies in financial crime detection, recommendations, and drug discovery. This talk is intended to introduce the concept of graph based AI to beginners, as well as help practitioners understand new techniques and applications. Key take aways: how graph data can improve machine learning, when graphs are relevant to data science applications, what graph native learning is and how to get started.
Kafka streams windowing behind the curtain confluent
Kafka Streams Windowing Behind the Curtain, Neil Buesing, Principal Solutions Architect, Rill
https://www.meetup.com/TwinCities-Apache-Kafka/events/279316299/
Mark and Wes will talk about Cypher optimization techniques based on real queries as well as the theoretical underlying processes. They'll start from the basics of "what not to do", and how to take advantage of indexes, and continue to the subtle ways of ordering MATCH/WHERE/WITH clauses for optimal performance as of the 2.0.0 release.
Confluent REST Proxy and Schema Registry (Concepts, Architecture, Features)Kai Wähner
High level introduction to Confluent REST Proxy and Schema Registry (leveraging Apache Avro under the hood), two components of the Apache Kafka open source ecosystem. See the concepts, architecture and features.
Temporal-Joins in Kafka Streams and ksqlDB | Matthias Sax, ConfluentHostedbyConfluent
Joins in Kafka Streams and ksqlDB are a killer-feature for data processing and basic join semantics are well understood. However, in a streaming world records are associated with timestamps that impact the semantics of joins: welcome to the fabulous world of _temporal_ join semantics. For joins, timestamps are as important as the actual data and it is important to understand how they impact the join result.
In this talk we want to deep dive on the different types of joins, with a focus of their temporal aspect. Furthermore, we relate the individual join operators to the overall ""time engine"" of the Kafka Streams query runtime and explain its relationship to operator semantics. To allow developers to apply their knowledge on temporal join semantics, we provide best practices, tip and tricks to ""bend"" time, and configuration advice to get the desired join results. Last, we give an overview of recent, and an outlook to future, development that improves joins even further.
Data Build Tool (DBT) is an open source technology to set up your data lake using best practices from software engineering. This SQL first technology is a great marriage between Databricks and Delta. This allows you to maintain high quality data and documentation during the entire datalake life-cycle. In this talk I’ll do an introduction into DBT, and show how we can leverage Databricks to do the actual heavy lifting. Next, I’ll present how DBT supports Delta to enable upserting using SQL. Finally, we show how we integrate DBT+Databricks into the Azure cloud. Finally we show how we emit the pipeline metrics to Azure monitor to make sure that you have observability over your pipeline.
With Apache Kafka 0.9, the community has introduced a number of features to make data streams secure. In this talk, we’ll explain the motivation for making these changes, discuss the design of Kafka security, and explain how to secure a Kafka cluster. We will cover common pitfalls in securing Kafka, and talk about ongoing security work.
Adventures with the ClickHouse ReplacingMergeTree EngineAltinity Ltd
Presentation on ReplacingMergeTree by Robert Hodges of Altinity at the 14 December 2022 SF Bay Area ClickHouse Meetup (https://www.meetup.com/san-francisco-bay-area-clickhouse-meetup/events/289605843/)
Maps and Meaning: Graph-based Entity Resolution in Apache Spark & GraphXDatabricks
Data integration and the automation of tedious data extraction tasks are the fundamental building blocks of a data-driven organizations and are overlooked or underestimated at times. Aside from data extraction, scraping and ETL tasks, entity resolution is a crucial step in successfully combining datasets. The combination of data sources is usually what provides richness in features and variance. Building an expertise in entity resolution is important for data engineerings to successfully combine data sources. Graph-based entity resolution algorithms have emerged as a highly effective approach.
This talk will present the implementation of a graph-bases entity resolution technique in GraphX and in GraphFrames respectively. Working from concept, through how to implement the algorithm in Spark, the technique will also be illustrated by walking through a practical example. The technique will exhibit an example where efficacy can be achieved based on simple heuristics, and at the same time map a path to a machine-learning assisted entity resolution engine with a powerful knowledge graph at its center.
The role of ML can be found upstream in building the graph, for example by using classification algorithms in determining the link strength between nodes based on data, or downstream where dimensionality reduction can play a role in clustering and reduce the computational load in the resolution stage. The audience will leave with a clear picture of a scalable data pipeline performing entity resolution effectively and a thorough understanding of the internal mechanism, ready to apply it to their use cases.
Review the latest features released in Neo4j version 4.1 including Cypher, database drivers, clustering, security, and extension libraries like APOC and Spring Data Neo4j!
Video of the presentation can be seen here: https://www.youtube.com/watch?v=uxuLRiNoDio
The Data Source API in Spark is a convenient feature that enables developers to write libraries to connect to data stored in various sources with Spark. Equipped with the Data Source API, users can load/save data from/to different data formats and systems with minimal setup and configuration. In this talk, we introduce the Data Source API and the unified load/save functions built on top of it. Then, we show examples to demonstrate how to build a data source library.
Building Cloud-Native App Series - Part 4 of 11
Microservices Architecture Series
NoSQL vs SQL
Redis, MongoDB, AWS DynamoDB
Big Data Design Patterns
Sharding, Partitions
ksqlDB is a stream processing SQL engine, which allows stream processing on top of Apache Kafka. ksqlDB is based on Kafka Stream and provides capabilities for consuming messages from Kafka, analysing these messages in near-realtime with a SQL like language and produce results again to a Kafka topic. By that, no single line of Java code has to be written and you can reuse your SQL knowhow. This lowers the bar for starting with stream processing significantly.
ksqlDB offers powerful capabilities of stream processing, such as joins, aggregations, time windows and support for event time. In this talk I will present how KSQL integrates with the Kafka ecosystem and demonstrate how easy it is to implement a solution using ksqlDB for most part. This will be done in a live demo on a fictitious IoT sample.
Transforming AI with Graphs: Real World Examples using Spark and Neo4jDatabricks
Graphs – or information about the relationships, connection, and topology of data points – are transforming machine learning. We’ll walk through real world examples of how to get transform your tabular data into a graph and how to get started with graph AI. This talk will provide an overview of how we to incorporate graph based features into traditional machine learning pipelines, create graph embeddings to better describe your graph topology, and give you a preview of approaches for graph native learning using graph neural networks. We’ll talk about relevant, real world case studies in financial crime detection, recommendations, and drug discovery. This talk is intended to introduce the concept of graph based AI to beginners, as well as help practitioners understand new techniques and applications. Key take aways: how graph data can improve machine learning, when graphs are relevant to data science applications, what graph native learning is and how to get started.
Kafka streams windowing behind the curtain confluent
Kafka Streams Windowing Behind the Curtain, Neil Buesing, Principal Solutions Architect, Rill
https://www.meetup.com/TwinCities-Apache-Kafka/events/279316299/
Mark and Wes will talk about Cypher optimization techniques based on real queries as well as the theoretical underlying processes. They'll start from the basics of "what not to do", and how to take advantage of indexes, and continue to the subtle ways of ordering MATCH/WHERE/WITH clauses for optimal performance as of the 2.0.0 release.
Confluent REST Proxy and Schema Registry (Concepts, Architecture, Features)Kai Wähner
High level introduction to Confluent REST Proxy and Schema Registry (leveraging Apache Avro under the hood), two components of the Apache Kafka open source ecosystem. See the concepts, architecture and features.
Temporal-Joins in Kafka Streams and ksqlDB | Matthias Sax, ConfluentHostedbyConfluent
Joins in Kafka Streams and ksqlDB are a killer-feature for data processing and basic join semantics are well understood. However, in a streaming world records are associated with timestamps that impact the semantics of joins: welcome to the fabulous world of _temporal_ join semantics. For joins, timestamps are as important as the actual data and it is important to understand how they impact the join result.
In this talk we want to deep dive on the different types of joins, with a focus of their temporal aspect. Furthermore, we relate the individual join operators to the overall ""time engine"" of the Kafka Streams query runtime and explain its relationship to operator semantics. To allow developers to apply their knowledge on temporal join semantics, we provide best practices, tip and tricks to ""bend"" time, and configuration advice to get the desired join results. Last, we give an overview of recent, and an outlook to future, development that improves joins even further.
Data Build Tool (DBT) is an open source technology to set up your data lake using best practices from software engineering. This SQL first technology is a great marriage between Databricks and Delta. This allows you to maintain high quality data and documentation during the entire datalake life-cycle. In this talk I’ll do an introduction into DBT, and show how we can leverage Databricks to do the actual heavy lifting. Next, I’ll present how DBT supports Delta to enable upserting using SQL. Finally, we show how we integrate DBT+Databricks into the Azure cloud. Finally we show how we emit the pipeline metrics to Azure monitor to make sure that you have observability over your pipeline.
With Apache Kafka 0.9, the community has introduced a number of features to make data streams secure. In this talk, we’ll explain the motivation for making these changes, discuss the design of Kafka security, and explain how to secure a Kafka cluster. We will cover common pitfalls in securing Kafka, and talk about ongoing security work.
Adventures with the ClickHouse ReplacingMergeTree EngineAltinity Ltd
Presentation on ReplacingMergeTree by Robert Hodges of Altinity at the 14 December 2022 SF Bay Area ClickHouse Meetup (https://www.meetup.com/san-francisco-bay-area-clickhouse-meetup/events/289605843/)
A visual tour of the corresponding GraphDay 2017 article -- https://doi.org/10.5281/zenodo.583293.
A propositional axiom is stated -- "everything is a graph." The entailments of this axiom are discussed and problems are presented that don't lend themselves to an easy representation as vertices and edges.
Abstract: The universal graph is a theoretical construct capturing the idea that every aspect of reality can be modeled as a graph composed of vertices and edges and, as such, reality is a graph. From the physical world of atoms, people, and galaxies to the mental planes of thoughts, words, and knowledge, there exists a universal graph hosting all such structures. While this idea is enticing, there are still strides to be made in coming to terms with a reality that is not composed of atoms bound by spacetime, but instead, a graph composed of vertices united by edges.
The Gremlin traversal machine is composed of three components: a graph, a traversal, and a set of traversers. Learn how these components interact to enable distributed, vendor-agnostic, OLTP/OLAP-based graph computing.
This talk was presented live at DataStax's Support Summit in Carmel, CA (April 2017) and Engineering Summit in Las Vegas, NV (May 2017).
This talk argues that the future of data query/analytic languages will be all about embedding the language into the native programming language of the developer. As an example of this style, the Gremlin graph traversal language is presented. Gremlin can be represented in any programming language that supports function composition and function nesting. The language representation is then compiled to Gremlin bytecode to ultimately be executed by the/a Gremlin graph traversal machine. This enables both the Gremlin language and machine to be agnostic to the execution language.
This presentation was given on January 17, 2016 at the GraphDay conference in Austin, Texas. The slides demonstrate the use of wave dynamics in graph structures. Moreover, they demonstrate how to implement quantum processes on graph structures.
There is an associated article available at http://arxiv.org/abs/1511.06278 (Quantum Walks with Gremlin).
ACM DBPL Keynote: The Graph Traversal Machine and LanguageMarko Rodriguez
Learn about Apache TinkerPop's Gremlin traversal machine and language. Presented as the keynote for ACM's Database Programming Languages conference in Pittsburgh Pennsylvania on October 27, 2015.
A presentation of Apache TinkerPop's Gremlin language with running examples over the MovieLens dataset. Presented August 19, 2015 at NoSQL NOW in San Jose, California.
Faunus is a graph analytics engine built atop the Hadoop distributed computing platform. The graph representation is a distributed adjacency list, whereby a vertex and its incident edges are co-located on the same machine. Querying a Faunus graph is possible with a MapReduce-variant of the Gremlin graph traversal language. A Gremlin expression compiles down to a series of MapReduce-steps that are sequence optimized and then executed by Hadoop. Results are stored as transformations to the input graph (graph derivations) or computational side-effects such as aggregates (graph statistics). Beyond querying, a collection of input/output formats are supported which enable Faunus to load/store graphs in the distributed graph database Titan, various graph formats stored in HDFS, and via arbitrary user-defined functions. This presentation will focus primarily on Faunus, but will also review the satellite technologies that enable it.
Who am I and why do I feel that the world is not infinitely perfect? Which technologies should I use to rectify this situation? Enter the graph and the graph traversal.
A graph is a data structure composed of vertices/dots and edges/lines. A graph database is a software system used to persist and process graphs. The common conception in today's database community is that there is a tradeoff between the scale of data and the complexity/interlinking of data. To challenge this understanding, Aurelius has developed Titan under the liberal Apache 2 license. Titan supports both the size of modern data and the modeling power of graphs to usher in the era of Big Graph Data. Novel techniques in edge compression, data layout, and vertex-centric indices that exploit significant orders are used to facilitate the representation and processing of a single atomic graph structure across a multi-machine cluster. To ensure ease of adoption by the graph community, Titan natively implements the TinkerPop 2 Blueprints API. This presentation will review the graph landscape, Titan's techniques for scale by distribution, and a collection of satellite graph technologies to be released by Aurelius in the coming summer months of 2012.
There is nothing more fascinating and utterly mind-bending than traversing a graph. Those who succumb to this data processing pattern euphorically suffer from graph pathology.
This is a case study of the Graph Addict.
Gremlin is a graph traversal language that connects to various graph databases/frameworks.
* Neo4j [http://neo4j.org]
* OrientDB [http://orientechnologies.com]
* DEX [http://www.sparsity-technologies.com/dex]
* OpenRDF Sail [http://openrdf.org]
* JUNG [http://jung.sourceforge.net]
This lecture addresses the state of Gremlin as of the 0.9 (April 16, 2011).
This tutorial/lecture addresses various aspects of the graph traversal language Gremlin. In particular, the presentation focuses on Gremlin 0.7 and its application to graph analysis and manipulation.
Relational databases are perhaps the most commonly used data management systems. In relational databases, data is modeled as a collection of disparate tables. In order to unify the data within these tables, a join operation is used. This operation is expensive as the amount of data grows. For information retrieval operations that do not make use of extensive joins, relational databases are an excellent tool. However, when an excessive amount of joins are required, the relational database model breaks down. In contrast, graph databases maintain one single data structure---a graph. A graph contains a set of vertices (i.e. nodes, dots) and a set of edges (i.e. links, lines). These elements make direct reference to one another, and as such, there is no notion of a join operation. The direct references between graph elements make the joining of data explicit within the structure of the graph. The benefit of this model is that traversing (i.e. moving between the elements of a graph in an intelligent, direct manner) is very efficient and yields a style of problem-solving called the graph traversal pattern. This session will discuss graph databases, the graph traversal programming pattern, and their use in solving real-world problems.
Problem-Solving using Graph Traversals: Searching, Scoring, Ranking, and Reco...Marko Rodriguez
A graph is a data structure that links a set of vertices by a set of edges. Modern graph databases support multi-relational graph structures, where there exist different types of vertices (e.g. people, places, items) and different types of edges (e.g. friend, lives at, purchased). By means of index-free adjacency, graph databases are optimized for graph traversals and are interacted with through a graph traversal engine. A graph traversal is defined as an abstract path whose instance is realized on a graph dataset. Graph databases and traversals can be used for searching, scoring, ranking, and in concert, recommendation. This presentation will explore graph structures, algorithms, traversal algebras, graph-related software suites, and a host of examples demonstrating how to solve real-world problems, in real-time, with graphs. This is a whirlwind tour of the theory and application of graphs.
A Perspective on Graph Theory and Network ScienceMarko Rodriguez
The graph/network domain has been driven by the creativity of numerous individuals from disparate areas of the academic and the commercial sector. Examples of contributing academic disciplines include mathematics, physics, sociology, and computer science. Given the interdisciplinary nature of the domain, it is difficult for any single individual to objectively realize and speak about the space as a whole. Any presentation of the ideas is ultimately biased by the formal training and expertise of the individual. For this reason, I will simply present on the domain from my perspective---from my personal experiences. More specifically, from my perspective biased by cognitive and computer science.
This is an autobiographical lecture on my life (so far) with graphs/networks.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
FIDO Alliance Osaka Seminar: Passkeys at Amazon.pdf
The Graph Traversal Programming Pattern
1. The Graph Traversal Programming Pattern
Marko A. Rodriguez
Graph Systems Architect
http://markorodriguez.com
http://twitter.com/twarko
WindyCityDB - Chicago, Illinois – June 26, 2010
June 25, 2010
2. Abstract
A graph is a structure composed of a set of vertices (i.e. nodes, dots)
connected to one another by a set of edges (i.e. links, lines). The concept
of a graph has been around since the late 19th century, however, only in
recent decades has there been a strong resurgence in the development of
both graph theories and applications. In applied computing, since the late
1960s, the interlinked table structure of the relational database has been
the predominant information storage and retrieval paradigm. With the
growth of graph/network-based data and the need to efficiently process
such data, new data management systems have been developed. In
contrast to the index-intensive, set-theoretic operations of relational
databases, graph databases make use of index-free traversals. This
presentation will discuss the graph traversal programming pattern and its
application to problem-solving with graph databases.
8. The Undirected Graph
1. Vertices
• All vertices denote the same
type of object.
2. Edges
• All edges denote the same type
of relationship.
• All edges denote a symmetric
relationship.
9. Denoting an Undirected Structure in the Real World
Collaborator graph is an undirected graph. Road graph is an undirected graph.
10. A Line with a Triangle
Dots and lines are boring.
Lets add a triangle to one side of each line.
However, lets call a triangle-tipped line a directed edge.
11. The Directed Graph
1. Vertices
• All vertices denote the same
type of object.
2. Edges
• All edges denote the same type
of relationship.
• All edges denote an
asymmetric relationship.
12. Denoting a Directed Structure in the Real World
Twitter follow graph is a directed graph. Web href-citation graph is a directed graph.
13. Single Relational Structures
• Without a way to demarcate edges, all edges have the same
meaning/type. Such structures are called single-relational graphs.
• Single-relational graphs are perhaps the most common graph type
in graph theory and network science.
14. How Do You Model a World with Multiple Structures?
I-25
lives_in
lives_in
I-40
is
is
follows
follows
created
lives_in
is
created created
cites created
cites
15. The Limitations of the Single-Relational Graph
• A single-relational graph is only able to express a single type of vertex
(e.g. person, city, user, webpage).1
• A single-relational graph is only able to express a single type of edge
(e.g. collaborator, road, follows, citation).2
• For modelers, these are very limiting graph types.
1
This is not completely true. All n-partite single-relational graphs allow for the division of the vertex set
into n subsets, where V = n Ai : Ai ∩ Aj = ∅. Thus, its possible to implicitly type the vertices.
i
2
This is not completely true. There exists an injective, information-preserving function that maps any
multi-relational graph to a single-relational graph, where edge types are denoted by topological structures.
Rodriguez, M.A., “Mapping Semantic Networks to Undirected Networks,” International Journal of Applied
Mathematics and Computer Sciences, 5(1), pp. 39–42, 2009. [http://arxiv.org/abs/0804.0277]
16. The Gains of the Multi-Relational Graph
• A multi-relational graph allows for the explicit typing of edges
(e.g. “follows,” “cites,” etc.).
• By labeling edges, edges can have different meanings and vertices
can have different types.
follows : user → user
created : user → webpage
cites : webpage → webpage
...
created
17. Increasing Expressivity with Multi-Relational Graphs
cites
cites
created
created
created
follows
cites
follows
created follows
follows
follows
created
18. The Flexibility of the Property Graph
• A property graph extends a multi-relational graph by allowing for both
vertices and edges to maintain a key/value property map.
• These properties are useful for expressing non-relational data (i.e. data
not needing to be graphed).
• This allows for the further refinement of the meaning of an edge.
Peter Neubauer created the Neo4j webpage on 2007/10.
name=neo4j
name=peterneubauer
views=56781
created
date=2007/10
19. Increasing Expressivity with Property Graphs
name=neo4j
views=56781
page_rank=0.023 cites
cites
name=tenderlove
gender=male
created
created
created
date=2007/10
cites
follows
follows
created
name=peterneubauer follows
name=graph_blog follows
views=1000 follows
created
name=ahzf
name=twarko
age=30
20. Property Graph Instance Schema/Ontology
name=<string> name=<string>
age=<integer> views=<integer>
gender=<string> page_rank=<double>
user created webpage
date=<string>
follows cites
No standard convention, but in general, specify the types of vertices, edges, and the
properties they may contain. Look into the world of RDFS and OWL for more rigorous,
expressive specifications of graph-based schemas.
21. Property Graphs Can Model Other Graph Types
weighted graph
add weight attribute
property graph
remove attributes remove attributes no op
labeled graph no op semantic graph no op directed graph
remove edge labels remove edge labels
make labels URIs no op
remove directionality
rdf graph multi-graph
remove loops, directionality,
and multiple edges
simple graph no op undirected graph
NOTE: Given that a property graph is a binary edge graph, it is difficult to model an n-ary edge graph (i.e. a hypergraph).
23. Persisting a Graph Data Structure
• A graph is a relatively simple data structure. It can be
seen as the most fundamental data structure—something is
related to something else.
• Most every database can model a graph.3
3
For the sake of simplicity, the following examples are with respect to a directed, single-relational graph.
However, note that property graphs can be easily modeled by such databases as well.
24. Representing a Graph in a Relational Database
outV | inV
------------ A
A | B
A | C
C | D B C
D | A
D
25. Representing a Graph in a JSON Database
{
A : {
out : [B, C], in : [D] A
}
B : {
in : [A]
}
B C
C : {
out : [D], in : [A]
}
D : {
out : [A], in : [C] D
}
}
26. Representing a Graph in an XML Database
<graphml>
<graph>
<node id=A /> A
<node id=B />
<node id=C />
<edge source=A target=B />
<edge source=A target=C />
<edge source=C target=D /> B C
<edge source=D target=A />
</graph>
</graphml>
D
27. Defining a Graph Database
“If any database can represent a graph, then what
is a graph database?”
28. Defining a Graph Database
A graph database is any storage system that
provides index-free adjacency.45
4
There is no “official” definition of what makes a database a graph database. The one provided is my
definition. However, hopefully the following argument will convince you that this is a necessary definition.
5
There is adjacency between the elements of an index, but if the index is not the primary data structure
of concern (to the developer), then there is indirect/implicit adjacency, not direct/explicit adjacency. A
graph database exposes the graph as an explicit data structure (not an implicit data structure).
29. Defining a Graph Database
• Every element (i.e. vertex or edge) has a direct pointer to
its adjacent element.
• No O(log2(n)) index lookup required to determine which
vertex is adjacent to which other vertex.
• If the graph is connected, the graph as a whole is a single
atomic data structure.
30. Defining a Graph Database by Example
Toy Graph Gremlin
(stuntman)
B E
A
C D
31. Graph Databases and Index-Free Adjacency
B E
A
C D
• Our gremlin is at vertex A.
• In a graph database, vertex A has direct references to its adjacent vertices.
• Constant time cost to move from A to B and C . It is dependent upon the number
of edges emanating from vertex A (local).
34. Non-Graph Databases and Index-Based Adjacency
B E
A B C A
B,C E D,E
D E
C D
• Our gremlin is at vertex A.
• In a non-graph database, the gremlin needs to look at an index to determine what
is adjacent to A.
• log2(n) time cost to move to B and C . It is dependent upon the total number of
vertices and edges in the database (global).
35. Non-Graph Databases and Index-Based Adjacency
B E
A B C A
B,C E D,E
D E C D
The Index (explicit) The Graph (implicit)
36. Non-Graph Databases and Index-Based Adjacency
B E
A B C A
B,C E D,E
D E C D
The Index (explicit) The Graph (implicit)
37. Index-Free Adjacency
• While any database can implicitly represent a graph, only a
graph database makes the graph structure explicit.
• In a graph database, each vertex serves as a “mini index”
of its adjacent elements.6
• Thus, as the graph grows in size, the cost of a local step
remains the same.7
6
Each vertex can be intepreted as a “parent node” in an index with its children being its adjacent
elements. In this sense, traversing a graph is analogous in many ways to traversing an index—albeit the
graph is not an acyclic connected graph (tree).
7
A graph, in many ways, is like a distributed index.
38. Graph Databases Make Use of Indices
A B C
} Index of Vertices
(by id)
D E } The Graph
• There is more to the graph than the explicit graph structure.
• Indices index the vertices, by their properties (e.g. ids).
39. Graph Databases and Endogenous Indices
• Many indices are trees.8
• A tree is a type of constrained graph.9
• You can represent a tree with a graph.10
8
Even an “index” that is simply an O(n) container can be represented as a graph (e.g. linked list).
9
A tree is an acyclic connected graph with each vertex having at most one parent.
10
This follows as a consequence of a tree being a graph.
40. Graph Databases and Endogenous Indices
• Graph databases allows you to explicitly model indices
endogenous to your domain model. Your indices and
domain model are one atomic entity—a graph.11
• This has benefits in designing special-purpose index
structures for your data.
Think about all the numerous types of indices in the
geo-spatial community.12
Think about all the indices that you have yet to think
about.
11
Originally, Neo4j used itself as its own indexing system before moving to Lucene.
12
Craig Taverner explores the use of graph databases in GIS-based applications.
41. Graph Databases and Endogenous Indices
name property index
views property index gender property index
name=neo4j
views=56781
page_rank=0.023 cites
cites
name=tenderlove
gender=male
created
created
created
date=2007/10
cites
follows
follows
created
name=peterneubauer follows
name=graph_blog follows
views=1000 follows
created
name=ahzf
name=twarko
age=30
42. Graph Databases and Endogenous Indices
name property index
views property index gender property index
name=neo4j
views=56781
page_rank=0.023 cites
cites
name=tenderlove
gender=male
created
created
created
date=2007/10
cites
follows
follows
created
name=peterneubauer follows
name=graph_blog follows
views=1000 follows
created
name=ahzf
name=twarko
age=30
The Graph Dataset
44. Graph Traversals as the Foundation
• Question: Once I have my data represented as a
graph, what can I do with it?
• Answer: You can traverse over the graph to
solve problems.
46. Graph Database vs. Relational Database
• While any database can represent a graph, it takes time to
make what is implicit explicit.
• The graph database represents an explicit graph.
• The experiment that follows demonstrate the problem with
using lots of table JOINs to accomplish the effect of a
graph traversal.13
13
Though not presented in this lecture, similar results were seen with JSON document databases.
47. Neo4j vs. MySQL – Generating a Large Graph
• Generated a 1 million vertex/4 million edge graph with “natural statistics.”14
• Loaded the graph into both Neo4j and MySQL in order to empirically evaluate the
effect of index-free adjacency.
14
What is diagramed is a small subset of this graph 1 million vertex graph.
48. Neo4j vs. MySQL – The Experiment
• For each run of the experiment, a traverser (gremlin) is
placed on a single vertex.
• For each step, the traverser moves to its adjacent
vertices.
Neo4j (graph database): the adjacent vertices are provided by the
current vertex.15
MySQL (relational database): the adjacent vertices are provided by a
table JOIN.
• For the experiment, this process goes up to 5 steps.
15
You can think of a graph traversal, in a graph database, as a local neighborhood JOIN.
55. Neo4j vs. MySQL – The Results
total running time (ms) for step traverals of length n
total running time (ms) for traversals of length n
mysql
2.3x faster
neo4j
100000
time(ms)
60000
0 20000
2.6x faster
4.5x faster 1.9x faster
1 2 3 4
traversal length
steps
average over the 250 most dense vertices as root of the traveral
• At step 5, Neo4j completed it in 14 minutes.
• At step 5, MySQL was still running after 2 hours (process stopped).
56. Neo4j vs. MySQL – More Information
For more information on this experiment, please visit
http://markorodriguez.com/Blarko/Entries/2010/3/
29_MySQL_vs._Neo4j_on_a_Large-Scale_Graph_
Traversal.html
57. Why Use a Graph Database? – Data Locality
• If the solution to your problem can be represented as a local
process within a larger global data structure, then a graph
database may be the optimal solution for your problem.
• If the solution to your problem can be represented as being
with respect to a set of root elements, then a graph
database may be the optimal solution to your problem.
• If the solution to your problem does not require a global
analysis of your data, then a graph database may be the
optimal solution to your problem.
60. Some Graph Traversal Use Cases
• Local searches — “What is in the neighborhood around
A?”16
• Local recommendations — “Given A, what should A
include in their neighborhood?”17
• Local ranks — “Given A, how would you rank B relative to
A?”18
16
A can be an individual vertex or a set of vertices. This set is known as the root vertex set.
17
Recommendation can be seen as trying to increase the connectivity of the graph by recommending
vertices (e.g. items) for another vertex (e.g. person) to extend an edge to (e.g. purchased).
18
In this presentation, there will be no examples provided for this use case. However, note that searching,
ranking, and recommendation are presented in the WindyCityDB OpenLab Graph Database Tutorial. Other
terms for local rank are “rank with priors” or “relative rank.”
61. Graph Traversals with Gremlin Programming Language
Gremlin G = (V, E)
http://gremlin.tinkerpop.com
The examples to follow are as basic as possible to get the idea across. Note that
numerous variations to the themes presented can be created. Such variations are driven
by the richness of the underlying graph data set and the desired speed of evaluation.
62. Graph Traversals with Gremlin Programming Language
1 created 3
knows created
4
name = peter
age = 37
63. Graph Traversals with Gremlin Programming Language
vertex 3 in edges
vertex 1 out edges
edge label
edge out vertex
edge in vertex
1 created 3
knows created
4
name = peter
age = 37
vertex 4 properties vertex 4 id
64. Graph Traversal in Property Graphs
name=tobias
follows
name=alex created name=C
created
created
name=emil follows name=B
name=E
follows name=A
created
created
name=johan created name=D
follows
name=peter
Red vertices are people and blue vertices are webpages.
65. Local Search: “Who are the followers of Emil Eifrem?”
name=tobias
follows
name=alex created name=C
created
created
name=emil follows 2 name=B name=alex
name=E
name=A
1 follows 2 name=johan
created
created
name=johan created name=D
follows
name=peter ./outE[@label=ʻfollowsʼ]/inV
66. Local Search: “What webpages did Emil’s followers
create?”
name=tobias
follows
created name=C
name=alex 3
created
created
name=emil follows 2 name=B name=B
name=E
name=A name=A
1 follows 2
created
created
name=johan 3 created name=D
follows
./outE[@label=ʻfollowsʼ]/inV
name=peter /outE[@label=ʻcreatedʼ]/inV
67. Local Search: “What webpages did Emil’s followers
followers create?”
name=tobias
follows
name=alex
3 created name=C
name=C
created
created
name=emil 4
follows 2 name=B name=D
name=E
1 follows 2 name=A 4 4 name=E
created
created 4
name=E
name=johan created name=D
3
follows
./outE[@label=ʻfollowsʼ]/inV/
name=peter outE[@label=ʻfollowsʼ]/inV/
outE[@label=ʻcreatedʼ]/inV
68. Local Recommendation: “If you like webpage E, you
may also like...”
name=tobias
follows
2 created name=C
name=alex
created
created
3
name=emil follows name=B name=C
name=E
name=A
1 name=D
follows
created
created 3
name=johan name=D
2 created
follows
./inV[@label='created']/outV/
name=peter outE[@label='created']/inV[g:except($_)]
Assumption: if you like a webpage by X , you will like others that they have created.
69. Local Recommendation: “If you like Johan, you may also
like...”
name=tobias
follows
name=alex created name=C
created
created
name=emil follows 3 name=B
name=E name=alex
2 follows 1 name=A
created
created
name=johan created name=D
follows
./inV[@label='follows']/outV/
name=peter outE[@label='follows']/inV
Assumption: if many people follow the same two people, then those two may be similar.
70. Assortment of Other Specific Graph Traversal Use Cases
• Missing friends: Find all the friends of person A. Then find all the
friends of the friends of person A that are not also person A’s friends.19
./outE[@label=‘friend’]/inV[g:assign(‘$x’)]/
outE[@label=‘friend’]/inV[g:except($x)]
• Collaborative filtering: Find all the items that the person A likes. Then
find all the people that like those same items. Then find which items
those people like that are not already the items that are liked by person
A.20
./outE[@label=‘likes’]/inV[g:assign(‘$x’)]/
inE[@label=‘likes’]/outV/outE[@label=‘likes’]/inV[g:except($x)]
19
This algorithm is based on the notion of trying to close “open triangles” in the friendship graph. If
many of person A’s friends are friends with person B , then its likely that A and B know each other.
20
This is the most concise representation of collaborative filtering. There are numerous modifications to
this general theme that can be taken advantage of to alter the recommendations.
71. Assortment of Other Specific Graph Traversal Use Cases
• Question expert identification: Find all the tags associated with
question A. For all those tag, find all answers (for any questions) that
are tagged by those tags. For those answers, find who created those
answers.21
./inE[@label=‘tag’]/outV[@type=‘answer’]/inE[@label=‘created’]/outV
• Similar tags: Find all the things that tag A has been used as a tag for.
For all those things, determine what else they have been tagged with.22
./inE[@label=‘tag’]/outV/outE[@label=‘tag’]/inV[g:except($_)]
21
If two resources share a “bundle” of resources in common, then they are similar.
22
This is the notion of “co-association” and can be generalized to find the similarity of two resources
based upon their co-association through a third resource (e.g. co-author, co-usage, co-download, etc.). The
third resource and the edge labels traversed determine the meaning of the association.
72. Some Tips on Graph Traversals
• Ranking, scoring, recommendation, searching, etc. are all
variations on the basic theme of defining abstract paths
through a graph and realizing instances of those paths
through traversal.
• The type of path taken determines the meaning
(i.e semantics) of the rank, score, recommendation, search,
etc.
• Given the data locality aspect of graph databases, many of
these traversals run in real-time (< 100ms).
73. Property Graph Algorithms in General
• There is a general framework for mapping all the standard single-relational
graph analysis algorithms over to the property graph domain.23
Geodesics: shortest path, eccentricity, radius, diameter, closeness,
betweenness, etc.24
Spectral: random walks, page rank, spreading activation, priors, etc.25
Assortativity: scalar or categorical.
... any graph algorithm in general.
• All able to be represented in Gremlin.
23
Rodriguez M.A., Shinavier, J., “Exposing Multi-Relational Networks to Single-Relational Network Analysis
Algorithms,” Journal of Informetrics, 4(1), pp. 29–41, 2009. [http://arxiv.org/abs/0806.2274]
24
Rodriguez, M.A., Watkins, J.H., “Grammar-Based Geodesics in Semantic Networks,” Knowledge-Based
Systems, in press, 2010.
25
Rodriguez, M.A., “Grammar-Based Random Walkers in Semantic Networks,” Knowledge-Based Systems,
21(7), pp. 7270–739, 2008. [http://arxiv.org/abs/0803.4355]
74. Conclusion
• Graph databases are efficient with respects to local data
analysis.
• Locality is defined by direct referent structures.
• Frame all solutions to problems as a traversal over local
regions of the graph.
This is the Graph Traversal Pattern.
75. Acknowledgements
• Pavel Yaskevich for advancing Gremlin. Pavel is currently writing a
new compiler that will make Gremlin faster and more memory efficient.
• Peter Neubauer for his collaboration on many of the ideas discussed in
this presentation.
• The rest of the Neo4j team (Emil, Johan, Mattias, Alex, Tobias, David,
Anders (1 and 2)) for their comments.
• WindyCityDB organizers for their support.
• AT&T Interactive (Aaron, Rand, Charlie, and the rest of the Buzz
team) for their support.
76. References to Related Work
• Rodriguez, M.A., Neubauer, P., “Constructions from Dots and Lines,” Bulletin
of the American Society of Information Science and Technology, June 2010.
[http://arxiv.org/abs/1006.2361]
• Rodriguez, M.A., Neubauer, P., “The Graph Traversal Pattern,” AT&Ti and
NeoTechnology Technical Report, April 2010. [http://arxiv.org/abs/1004.1001]
• Neo4j: A Graph Database [http://neo4j.org]
• TinkerPop [http://tinkerpop.com]
Blueprints: Data Models and their Implementations [http://blueprints.tinkerpop.com]
Pipes: A Data Flow Framework using Process Graphs [http://pipes.tinkerpop.com]
Gremlin: A Graph-Based Programming Language [http://gremlin.tinkerpop.com]
Rexster: A Graph-Based Ranking Engine [http://rexster.tinkerpop.com]
∗ Wreckster: A Ruby API for Rexster [http://github.com/tenderlove/wreckster]