<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Haikal Ryclova-Pribadi on Medium]]></title>
        <description><![CDATA[Stories by Haikal Ryclova-Pribadi on Medium]]></description>
        <link>https://medium.com/@haikal?source=rss-5ef03fa74362------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*cdBwjUhBZtn22Y0U54xVPg.jpeg</url>
            <title>Stories by Haikal Ryclova-Pribadi on Medium</title>
            <link>https://medium.com/@haikal?source=rss-5ef03fa74362------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:21:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@haikal/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[A New Era for TypeDB]]></title>
            <link>https://medium.com/vaticle/a-new-era-for-typedb-5580c7421e89?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/5580c7421e89</guid>
            <category><![CDATA[strongly-typed]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[programming-languages]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Fri, 07 Jul 2023 23:43:22 GMT</pubDate>
            <atom:updated>2023-09-11T15:08:16.170Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The original version of this article is published at </em><a href="https://typedb.com/blog/a-new-era-for-typedb"><em>https://typedb.com/blog/a-new-era-for-typedb</em></a><em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zwaaYCQYZEM9j9FaGq7NFA.png" /></figure><p>When we started building TypeDB, we saw a continuously growing complexity of data in modern applications. Modern programming languages have evolved by introducing powerful abstractions and constructs to express more complex logic — JavaScript is succeeded by TypeScript, Python by Julia, Java by Kotlin, C/C++ by Rust, and Haskell emerging as the leader of functional languages. <strong>Modern languages all have a stronger and more expressive type system.</strong></p><p>However, when we look at the evolution of database technologies since relational algebra and SQL, even though there has been incredible progress in performance and operational capabilities in the past 40 years, <strong>databases have yet to provide more powerful abstractions to express more advanced logic</strong>. In fact, graph, document, key-value, wide-column, and every other NoSQL database provide lower-level and more primitive data structures for us to express our models and queries. This is a huge problem for future applications, as they will need to work with more complex datasets and interrogate their data more intelligently.</p><p><strong>We built TypeDB &amp; TypeQL to provide much more powerful abstractions in the database language</strong>, allowing you to tackle the next order of complexity in future applications. For the first time, TypeDB brings to the database the power of a <strong>strong type system</strong>, the simplicity of a <strong>composable language</strong>, and the intelligence of <strong>symbolic reasoning</strong> to infer data.</p><p>This year, we’re launching <a href="https://typedb.com/"><strong>typedb.com</strong></a> to help you understand <a href="https://typedb.com/introduction"><strong>our paradigm</strong></a> and <a href="https://typedb.com/features"><strong>unique features</strong></a>, and to deliver a brand new and enhanced <a href="https://typedb.com/docs/typedb/2.x/overview.html"><strong>documentation portal</strong></a>. We are also incredibly excited to invite you to the very first <a href="https://typedb.com/webinars"><strong>webinar series</strong></a> on TypeDB Fundamentals, happening in just 3 weeks!</p><ol><li><a href="https://typedb.com/webinars/introducing-typedb"><strong>July 25th, 12pm ET: Introducing TypeDB</strong></a></li><li><a href="https://typedb.com/webinars/pattern-matching"><strong>July 26th, 12pm ET: Pattern Matching with TypeQL</strong></a></li><li><a href="https://typedb.com/webinars/power-of-inference"><strong>July 27th, 12pm ET: The Power of Inference</strong></a></li></ol><p>We see the problem of data complexity in many modern applications, especially those serving intelligent operations.</p><p>In <a href="https://typedb.com/solutions/cybersecurity"><strong>Cybersecurity</strong></a>, Cyber Threat Intelligence and Identity Access Management solutions struggle to keep up with rapid evolution of data and the amount of hidden patterns. In <a href="https://typedb.com/solutions/platform-engineering"><strong>Platform Engineering</strong></a>, Internal Developer Platforms and Continuous Delivery systems struggle with the unknown consequences of change and fragmentation of data. In <a href="https://typedb.com/solutions/knowledge-engineering"><strong>Knowledge Engineering</strong></a>, Drug Discovery and Risk Management solutions find that their biggest hurdle is connecting independent datasets in a way that makes it easy to derive hidden and implicit connections. <a href="https://typedb.com/solutions/virtual-representations"><strong>Virtual Representations</strong></a>, such as those found in Robotics, Digital Twins, and Gaming, struggle with modeling real-world details in a virtual environment.</p><p>This year, we’ll be sharing with you the research we’ve done on applications of TypeDB in these advanced domains, starting with our first <a href="https://typedb.com/webinars"><strong>webinar series</strong></a> on our new TypeDB Use Cases, happening 4 weeks from now!</p><ol><li><a href="https://typedb.com/webinars/identity-access-management"><strong>August 1st, 12pm ET: Building an IAM Platform on TypeDB</strong></a></li><li><a href="https://typedb.com/webinars/cyber-threat-intelligence"><strong>August 2nd, 12pm ET: Building a CTI Platform on TypeDB</strong></a></li><li><a href="https://typedb.com/webinars/drug-discovery"><strong>August 3rd, 12pm ET: Accelerating Drug Discovery with TypeDB</strong></a></li></ol><h3>At last, <a href="https://typedb.com/cloud">TypeDB Cloud</a> Alpha is here!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m1yKI5wVYkNTa0ilj-WGEA.png" /><figcaption>TypeDB Cloud Alpha</figcaption></figure><p>After a whole year of engineering, we are finally ready to invite you to try out <a href="https://typedb.com/cloud"><strong>TypeDB Cloud</strong></a>! You can now automatically deploy TypeDB in the US and Europe, on Google Cloud and Amazon AWS. More regions across the globe will be coming soon, as well as the option for Microsoft Azure. At this alpha stage of TypeDB Cloud, we’d love to hear your feedback on how TypeDB Cloud meets your expectations, and you’ll have the opportunity to contribute to our development roadmap! <a href="https://typedb.com/cloud?dialog=cloud-waitlist"><strong>Join the TypeDB Cloud waitlist!</strong></a></p><h3>Finally, <a href="https://typedb.com/">TypeDB 2.18 &amp; 2.19</a> are released with major updates!</h3><p>We’ve had 2 major releases in the past month: 2.18 and 2.19. We introduced new functionalities to perform <strong>arithmetic operations</strong> in TypeQL. We’ve significantly improved <strong>import/export of schema &amp; data</strong> together. We dramatically improved the <strong>performance of our reasoner</strong> by reusing more of its computational results. We replaced our <strong>storage engine</strong> from <a href="https://rocksdb.org/">RocksDB</a> to <a href="https://rocksdb.org/">SpeeDB</a> — boosting performance. And finally, we now <strong>natively support ARM processors</strong> for both Mac and Linux, which means you can run TypeDB on <strong>Apple silicon</strong> chips as well as <strong>Raspberry Pis</strong>!</p><ul><li><a href="https://github.com/vaticle/typedb/releases/tag/2.18.0">TypeDB 2.18 Release Notes</a></li><li><a href="https://github.com/vaticle/typedb/releases/tag/2.19.0">TypeDB 2.19 Release Notes</a></li></ul><p>There are a lot more major updates coming in the next few months: a new and <strong>highly-performant TypeDB Rust driver</strong> — and every other driver wrapping the Rust driver binary, new TypeQL capabilities to <strong>fetch all attributes</strong> of entities and relations as part of answers, <strong>optional query patterns</strong> in TypeQL, <strong>native JSON response</strong> format, and many more! For now, we hope you enjoy the new TypeDB 2.19! <a href="https://typedb.com/deploy"><strong><em>Deploy your new TypeDB!</em></strong></a></p><h3>Further Resources</h3><ul><li><a href="https://typedb.com/white-papers/cyber-threat-intelligence">Cyber Threat Intelligence White Paper</a></li><li><a href="https://typedb.com/white-papers/machine-learning">Machine Learning White Paper</a></li><li><a href="https://typedb.com/white-papers/robotics">Robotics White Paper</a></li><li><a href="https://typedb.com/white-papers/drug-discovery">Accelerating Drug Discovery White Paper</a></li></ul><p>If you want to hear more of our updates, <a href="https://typedb.com/?dialog=newsletter"><strong><em>subscribe to our newsletter!</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5580c7421e89" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/a-new-era-for-typedb-5580c7421e89">A New Era for TypeDB</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grakn 2.0 Alpha: best practices of Distributed Systems and Computer Science]]></title>
            <link>https://medium.com/vaticle/grakn-2-0-alpha-best-practices-of-distributed-systems-and-computer-science-960da9a9bc44?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/960da9a9bc44</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Wed, 13 Jan 2021 23:24:23 GMT</pubDate>
            <atom:updated>2022-03-25T15:48:04.072Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T6IzRVlzkc3KEhuk.png" /><figcaption>Grakn Core 2.0.0 Alpha</figcaption></figure><blockquote>Grakn is a distributed knowledge graph: a <a href="https://en.wikipedia.org/wiki/Logic_in_computer_science">logical</a> database to organise large and <a href="https://en.wikipedia.org/wiki/Complex_network">complex networks</a> of data as one body of knowledge. Visit <a href="http://www.vaticle.com/">grakn.ai</a> to learn more.</blockquote><p>When we kicked-off 2020, we were so excited to launch <a href="https://grakncosmos.com/">Grakn Cosmos</a>: Grakn’s first global conference, held here in London in the first week of February. It was an intense start to the year, but we learnt so much about how our community was using <a href="http://www.vaticle.com/">Grakn </a>to solve some of the most complex problems in their industries. We met with our community members from Life Sciences, Defence &amp; Security, Financial Services, Robotics, and many other sectors. From financial analytics to drug discovery, cyber threat detection to robotics disaster recovery, Grakn was being used to tackle a higher order of complexity in data and knowledge, and it inspired all of us at Grakn Labs.</p><p>We genuinely believe the technologies built by our community can truly change the world one day. However, we also learnt an important lesson from the community that week: Grakn was not fast enough, and we needed to scale the <em>performance</em>.</p><p>We were deeply moved by our community’s works and how they were impacting their respective domains. We knew that we had to do something big to overcome this massive hurdle that’s holding everyone back, and make it the priority of 2020 — no excuses.</p><p>And so we took the best of our design, engineering, mathematics, and computer science, from our work over the past five years — just the parts that we know our community loved — and we re-wrote Grakn from scratch [1]. <strong>We rebuilt Grakn with an entirely new architecture of best practices in Distributed Systems and Computer Science.</strong></p><p>But most importantly, we rebuilt Grakn with a new mindset. One that would set the trajectory of our work for decades to come.</p><blockquote><em>[1] </em>About the only thing we kept from the old Grakn’s codebase was our test framework, which was <strong>essential to guarantee stability and no regression</strong>. So we kept it and extended it by multiple folds.</blockquote><p>We find it crucial that we share with the community the decisions that went into Grakn 2.0, hence the length of this post. We’ll publish our benchmarking figures very soon, and the points below explain how and why you will see multiple orders of magnitude in performance improvements. The points below also explain why we needed to rewrite the entire Grakn codebase. <strong>Grakn 2.0 is effectively a newly written Grakn</strong>, with the old test framework migrated and extended to guarantee stability does not regress.</p><p>As this is an “ALPHA” release, we would like to remind our community that this is not a production release. We expect to release a production-ready Grakn 2.0 end of this month (end of January 2021) after we go through a series of planned stress-testing and benchmarking regime.</p><p><strong>In the meantime, we’d like to ask the community to help us</strong> stress test the new Grakn, and submit any bugs to us as “issues” on GitHub (through the most relevant repository) following the issue template to fill in the steps that can help us reproduce them.</p><p><strong>To install and start using Grakn 2.0.0-alpha</strong>, visit our “staging” documentation website at <a href="https://dev.docs.grakn.ai/">dev.docs.grakn.ai</a>, and visit <a href="http://dev.docs.grakn.ai/docs/running-grakn/install-and-run">Install &amp; Run</a>. [2][3][4][5][6]</p><blockquote><em>[2] </em>Grakn 2.0.0-alpha is only accessible and documented through our “staging” documentation website (<a href="https://dev.docs.grakn.ai/">dev.docs.grakn.ai</a>) right now. The main documentation (<a href="https://docs.grakn.ai/">docs.grakn.ai</a>) and website (<a href="http://www.vaticle.com/">grakn.ai</a>) will continue serving Grakn 1.8.4 until we release Grakn 2.0.0 for production.<em><br>[3] </em>Workbase is not yet compatible with Grakn 2.0.0-alpha, and will be coming very soon.<em><br>[4] </em>Reasoner will be enabled in the coming week(s).<em><br>[5] </em>Performances of all queries are not final yet. For example, sorting and grouping on match queries are still implemented naively.<em><br>[6] </em>Pay attention to the nightly releases of <a href="http://github.com/graknlabs/grakn/releases">Grakn</a>, <a href="http://github.com/graknlabs/graql/releases">Graql</a>, <a href="http://github.com/graknlabs/client-java/releases">Client Java</a>, <a href="https://pypi.org/project/grakn-client/#history">Client Python</a> and <a href="https://www.npmjs.com/package/grakn-client">Client Node.js</a> as we’ll be frequently submitting patches throughout this Alpha phase.</blockquote><p><strong>We <em>tried</em> refactoring …</strong></p><p>At the start of 2020, Grakn exclusively depended on <a href="https://janusgraph.org/">JanusGraph</a> as our graph storage engine, and <a href="https://tinkerpop.apache.org/">TinkerPop/Gremlin</a> as the (internal) graph query language. JanusGraph itself was built on top of <a href="https://cassandra.apache.org/">Cassandra</a> as the Key-Value storage engine. There has been great work that went into JanusGraph by their community (which we’re hugely thankful for). However, we knew all along that <strong>JanusGraph was not the right storage</strong> for the type of computation that Grakn’s knowledge representation and reasoning system needed to perform.</p><p>We always planned that when performance becomes the bottleneck, we’d “open the bonnet”, and refactor and optimise the JanusGraph codebase to fit our usage. So, after Cosmos, we spent some time understanding the JanusGraph source code, but we quickly grasped the complexity of the codebase. However, most of the code in JanusGraph, which includes TinkerPop/Gremlin implementation, was written for purposes that don’t serve any of our needs in Grakn. And the effort to untangle it did not seem feasible.</p><p>That was the moment when we realised the right thing to do was <strong>to build our own graph storage engine</strong> — one that was custom-built for our knowledge representation system, tailored to our hypergraph data structures, and will forever be fully in our control.</p><h4>1) Replaced <a href="https://cassandra.apache.org/">Cassandra</a> with <a href="https://rocksdb.org/">RocksDB</a></h4><p>If we’re going to replace <a href="https://janusgraph.org/">JanusGraph</a> graph, we might as well ask: should we keep <a href="https://cassandra.apache.org/">Cassandra</a> as the key-value storage? <strong>What’s the fastest key-value storage we should use to build Grakn? </strong>This research quickly leads us to <a href="https://rocksdb.org/">RocksDB</a>, a powerful open-source, low-level key-value storage engine, built by the <a href="https://github.com/facebook">engineering team at Facebook</a>. RocksDB is an embedded storage engine, commonly used to build higher-level databases. It’s written entirely in C++ for max performance, where “keys” and “values” are simply arbitrarily-sized byte arrays, easily suitable for storing multiple terabytes of data in a single server. It’s optimised for fast, low latency storage, and it exploits the full potential of high read/write rates offered by flash or RAM — exactly what we want. Beyond Facebook, <a href="https://github.com/facebook/rocksdb/blob/master/USERS.md">RocksDB has been widely adopted</a> among established companies. <strong>RocksDB has been proven to be a scalable, embedded storage engine</strong> for numerous other database technologies.</p><h4>2) New Graph Storage Engine: replacing <a href="https://janusgraph.org/">JanusGraph</a></h4><p>Using <a href="https://rocksdb.org/">RocksDB</a> as our key-value storage, <strong>we built a new graph storage engine</strong>, custom-built for Grakn’s <a href="https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning">knowledge representation</a> system, tailored to our <a href="https://en.wikipedia.org/wiki/Hypergraph">hypergraph</a> data structure. The graph is still a <em>“</em><a href="https://en.wikipedia.org/wiki/Directed_graph"><em>directed binary graph</em></a><em>”</em>, but it is made of 2 co-existing graphs: the <em>“schema graph”</em> and the <em>“data graph”</em>. The schema graph serves as a constraint to the data graph. Both graphs manage data that sits in RAM, storage, and any movement in between, transparently. You can consider these graphs as a <strong><em>hybrid of in-memory and persisted graph</em></strong>. The schema graph is unique in that it always lives in memory for as long as it can. Both graphs are thread-safe and designed for concurrent usage by frameworks that sit above it.</p><h4>3) New Grakn <a href="https://en.wikipedia.org/wiki/Type_system">Type System</a>: our Knowledge Representation</h4><p>Now that we have our own graph storage engine, tailored to our hypergraph data structures, we had the opportunity to rewrite our <a href="https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning">knowledge representation</a> system. This is the system that governs the types you define in your schema, verifies the correctness of your data, encodes the logical representation of persisted data, and serves as the foundation to the reasoning system. You can see this as <strong>Grakn’s <em>“</em></strong><a href="https://en.wikipedia.org/wiki/Type_system"><strong><em>type system</em></strong></a><strong><em>”</em></strong>, and we were able to rebuild it to be much more expressive, simpler and performant.</p><p>We extended the previous type system with <strong>more expressive type inheritance</strong>: role type inheritance and overriding attribute types and role types. We <strong>simplified the system</strong> by making role types scoped to their relation types: naming roles is now more straightforward and more user friendly. We introduced <strong>type-safety restrictions</strong>. We introduced a new system for exception handling, which provides much more <strong>helpful error messages</strong> to guide you in designing your schema. Last but not least, we rebuilt the type system to be <strong>thread-safe and always live in memory</strong>.</p><h4>4) New <a href="https://github.com/graknlabs/graql">Graql</a>: <a href="https://github.com/graknlabs/graql/releases/tag/2.0.0-alpha">even simpler and more powerful</a></h4><p>As a result of the change in our type system, Graql also needed to be changed. We kept the grammar almost entirely, especially in data queries, but we <strong>considerably improved the schema language</strong>. We introduced more expressive features, such as inheriting and overriding attribute types and role types, to reflect the type system’s new features. However, we also introduced changes that significantly simplify your schema, such as “scoping role types to their relation types”, making the Graql language <strong>even easier to use</strong>. Under-the-hood, we rebuilt Graql to natively have a graph data structure and be semantically logical — which made implementing everything else in Grakn so much easier. <strong>You should review full changelog in the </strong><a href="https://github.com/graknlabs/graql/releases/tag/2.0.0-alpha"><strong>Graql 2.0.0-alpha release notes</strong></a><strong>.</strong></p><h4>5) New Traversal Engine: replacing <a href="https://tinkerpop.apache.org/">TinkerPop/Gremlin</a></h4><p><a href="https://tinkerpop.apache.org/">TinkerPop/Gremlin</a> is a graph computing framework that allows graph storage engines, such as <a href="https://janusgraph.org/">JanusGraph</a>, to be queried using TinkerPop’s graph query language: <a href="https://tinkerpop.apache.org/gremlin.html">Gremlin</a>. For the first five years, <strong>Grakn has relied on TinkerPop/Gremlin to query the binary graph</strong> in which our knowledge representation system stored its data. Graql would be translated through our reasoning engine and eventually hit JanusGraph with a Gremlin query. We’ll always be hugely thankful to TinkerPop for enabling us to prove some fundamental questions in building a knowledge graph and reasoning engine.</p><p>However, now that we have our very own graph storage engine, we had the incredible opportunity to <strong>write our own traversal engine</strong>, that heavily <strong>optimises the traversal algorithms</strong> to our native hypergraph data structures. This is <strong>natively parallelised</strong> to exploit the graph storage being thread-safe.</p><h4>6) New Query Planner: an <a href="https://en.wikipedia.org/wiki/Linear_programming">Integer Linear Program</a></h4><p>Having our own storage engine also meant that we had the freedom to create and store various kinds of statistics/metadata about the data stored in the graph, categorised by the types in the schema that describes those data. All without affecting the performance of the storage engine. This opened a new opportunity for us: <strong>we can now perform a thrifty/non-greedy optimisation that considers the possible query plans more globally</strong>, through a “<a href="https://en.wikipedia.org/wiki/Mathematical_optimization">Mathematical Optimisation/Programming</a>” algorithm commonly known as “<a href="https://en.wikipedia.org/wiki/Linear_programming">Integer Linear Programming</a>”.</p><p>Given a query that a user writes, there are hundreds or thousands of possible execution paths to get the answers. Most of them would be too costly for the traversal engine to execute as they produce millions of permutations in the execution. Few of those paths would be efficient paths to traverse, and the difference could be multiple orders of magnitude in traversal performance. <strong>This is an inherent problem with databases, especially graph databases</strong>, as they expose the ability to query multiple degrees of relationships. If you leave it to the developer to determine the most efficient traversal execution path, this would be a very challenging task.</p><p>Integer Linear Programming algorithms allow us to create constraints that determine the bounds of a valid solution, and a goal function to optimise the solution with. The metadata about the graph that we now can store, enables us to generate goal functions that are aware of the cost of different parts of the graph upon which a query would traverse. <strong>This allows Grakn to <em>transparently</em> determine the most <em>“globally optimal”</em> path to execute the query</strong>, while the developer is left to determine the constraints that the query needs to satisfy.</p><h4>7) New Reasoning Engine: based on <a href="https://en.wikipedia.org/wiki/Event_loop">Event Loop</a> + <a href="https://en.wikipedia.org/wiki/Actor_model">Actor Model</a></h4><blockquote><em>[4] </em>We are in the midst of completing the new reasoning engine and it’s not yet enabled. It will be enabled in the coming week(s) through one of the <a href="https://github.com/graknlabs/grakn/releases">2.0.0-alpha nightly releases</a>.</blockquote><p>With a thread-safe graph storage and traversal engine designed for concurrent usage, again, we had the opportunity to redesign how Grakn’s reasoning engine works. Inspired by <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop">JavaScript’s Event Loop</a> and <a href="https://doc.akka.io/docs/akka/current/typed/actors.html">Akka’s Actor Model</a> <strong>we built our own </strong><a href="https://en.wikipedia.org/wiki/Event_loop"><strong>Event Loop</strong></a><strong> and </strong><a href="https://en.wikipedia.org/wiki/Actor_model"><strong>Actor Model</strong></a><strong> libraries</strong>. The event loop is a concurrent framework that collects events and executes their code in parallel. It is different from most concurrent frameworks in that it is non-blocking, zero-context-switching and asynchronous by nature, which allows it to have much higher throughput. The actor model is also a concurrent framework — one that allows concurrent computation be written through the model of an <em>“actor”</em>: a computational entity that can receive/send messages from/to other actors that result in the actor executing/designating a computational task.</p><p><strong>So we rewrote our reasoning engine to be natively modelled as concurrent actors, powered by our event loop.</strong> By representing reasoning operations as actors, we not only unlock <strong>massive scalability</strong> of computation, we are also able to reuse the results of computations, such as inferences and inference explanations. Streamlining the reasoning data structures also <strong>simplified the computational model</strong>, which resulted in fewer logical edge cases, more cachable states, and allowed us to add new features far more quickly. We also introduced a <em>“type resolver”</em>, which reasons over a Graql query, to <strong>validate user-written rules </strong>and prune the ones that are not relevant to the user’s query.</p><h4>8) New Query Engine: an Asynchronous <a href="https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem">Producer-Consumer</a></h4><p>Previously, a Graql query gets executed mostly single-threaded. Now, the graph traversal and reasoning engine are both parallelised. How can we leverage them (in tandem) in our query engine?</p><p>The answer was to introduce a higher level concurrent framework: <strong>an asynchronous </strong><a href="https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem"><strong>Producer-Consumer</strong></a><strong> framework</strong>. A producer-consumer pattern is a common pattern in distributed systems, where one or more concurrent jobs produces data into a queue, and one or more concurrent jobs read from the queue. In the case of Grakn: we saw the opportunity to use this pattern to <strong>allow concurrent computation of a query to produce <em>“answers”</em></strong> into a queue, and the server consumes those answers to return to the client. We also ensured that the concurrent jobs be non-blocking and run asynchronously to achieve maximum throughput.</p><p>Then we modelled the two computations, the graph traversal and reasoner (which itself leverages graph traversal), to be “producer” computations. Each computation can run concurrent jobs to produce answers to a queue. Both are inherently parallelised as explained above, and now both can run together in one producer-consumer framework: the query engine. <strong>Now every query will try to leverage the CPU resource as much as possible.</strong> [5]</p><blockquote><em>[5] </em>Performances of all queries are not final yet. For example, sorting and grouping on match queries are still implemented naively.</blockquote><h4>9) New Client-Server Protocol: a <a href="https://en.wikipedia.org/wiki/Reactive_Streams">Reactive Stream</a></h4><p>With the server performance scaled, we need to ensure the client-server communication was not a bottleneck. <strong>We want the client application to leverage the server’s asynchronous parallel computation</strong> to receive as many answers as possible, as soon as they are ready. However, we don’t want the client application to be overwhelmed with server responses. So, we needed some form of <em>“back-pressure”</em>. However, to maintain maximum throughput, everything had to be non-blocking. Sounds familiar? Well, <strong>it’s the <em>“</em></strong><a href="https://www.reactive-streams.org/"><strong><em>reactive stream</em></strong></a><strong><em>”</em> problem</strong>.</p><p>We took inspiration from <a href="https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Flow.html">Java Flow</a> and <a href="https://doc.akka.io/docs/akka/current/stream/index.html">Akka Stream</a>, and <strong>built our own reactive stream over </strong><a href="https://grpc.io/"><strong>GRPC</strong></a><strong>, as lightweight as possible, with our unique optimisations</strong>. When an application sends a query from the client to the server, a (configurable) batch of asynchronously computed answers will immediately be streamed from the server to the client. This reduces network roundtrips and increases throughput. Once the first batch is consumed, the client will request another batch. We remove waiting time between the first and second batch, by predicting that duration and streaming back surplus answers for a period of that duration, at the end of every batch. <strong>This allows us to maintain a continuous stream of answers at maximum throughput, without overflowing the application.</strong></p><p>We then hit the max limit of responses GRPC can send per second. So the last trick was to bundle multiple query answers into a single server RPC “response”. The impact on query response time was negligible, but it dramatically increased answer throughput again.</p><p>The new client <strong>architecture and </strong><a href="https://developers.google.com/protocol-buffers"><strong>Protobuf</strong></a><strong> definitions are also hugely simplified</strong> to ease the developers’ effort to build their own client libraries.</p><h4>10) New Grakn Cluster: a <a href="https://en.wikipedia.org/wiki/Raft_(algorithm)">Raft</a>-based distributed Grakn</h4><p>Grakn Cluster (previously called Grakn KGMS) is an extended version of Grakn that runs multiple database servers as one cluster, to provide scalability and high-availability for production deployments. Without <a href="https://cassandra.apache.org/">Cassandra</a>, we now need an alternative strategy to scale Grakn as a cluster. Naturally, we considered leveraging <a href="https://tikv.org/">TiKV</a>: a distributed key-value storage, also built using <a href="https://rocksdb.org/">RocksDB</a>. However, we needed something lower-level and more performant to scale our graph storage engine. <strong>So we built our own distributed storage using RocksDB.</strong></p><p>We considered the two established distribution protocols: <a href="https://en.wikipedia.org/wiki/Paxos_(computer_science)">Paxos</a> and <a href="https://en.wikipedia.org/wiki/Raft_(algorithm)">Raft</a>. Both have the same theoretical performance profile, but Raft is significantly simpler and more elegant. <strong>Using the same </strong><a href="https://en.wikipedia.org/wiki/Event_loop"><strong>Event Loop</strong></a><strong> and </strong><a href="https://en.wikipedia.org/wiki/Actor_model"><strong>Actor Model</strong></a><strong> libraries</strong> from Grakn Core (which actually originated from Grakn Cluster), <strong>we modelled the core Raft algorithm itself as a </strong><a href="https://en.wikipedia.org/wiki/Finite-state_machine"><strong>finite-state machine</strong></a>. The Raft algorithm is asynchronous by nature, but we ensured our implementation had no locks and mutexes, and we built Grakn Cluster as a fully event-driven and non-blocking system. Data replication was implemented through <a href="https://en.wikipedia.org/wiki/Message_passing">message-passing</a> using <a href="https://zeromq.org/">ZeroMQ</a>, which aligned with our <strong>asynchronous architecture</strong>.</p><p>The ultimate challenge was: how do you test an asynchronous distributed system, that is non-deterministic by nature? Inspired by <a href="https://apple.github.io/foundationdb/">Apple’s FoundationDB</a> team on how they <a href="https://apple.github.io/foundationdb/testing.html">simulated their distributed cluster</a>, <strong>we built our own Raft <em>“simulation”</em> framework</strong>, which allows us to run deterministic and repeatable simulations of an entire distributed cluster. If a bug is observed in a Raft simulation of cluster of size n and time t, then we can repeat the simulation with the same seed and configuration, to reproduce the bug.</p><h4>11) New <a href="https://github.com/graknlabs/console">Grakn Console</a>: powered by <a href="https://picocli.info/">PicoCLI</a> + <a href="https://jline.github.io/">JLine</a></h4><p><strong>We’ve also rebuilt the Grakn Console</strong>. We use <a href="https://picocli.info/">PicoCLI</a> to enable more expressive CLI utilities, allowing us to build a richer and user-friendly console environment for Grakn. We use <a href="https://jline.github.io/">JLine</a> to build an interactive console environment, which provides multiline editing, console command history, and many more features that help with the development in the console.</p><p><strong>The new Grakn Console provides two levels of interaction: database-level and transaction-level interfaces.</strong> The database-level interface is the first level of interaction, i.e. first-level REPL. From one of the database-level commands, you can open a transaction to the database. This will open a transaction-level interface, i.e. second-level REPL. <strong>You should review full changelog in the </strong><a href="https://github.com/graknlabs/console/releases/tag/2.0.0-alpha"><strong>Grakn Console 2.0.0-alpha release notes</strong></a><strong>.</strong></p><h4>12) New <a href="https://github.com/graknlabs/benchmark">Benchmarking System</a>: an <a href="https://en.wikipedia.org/wiki/Agent-based_model">Agent-based</a> Simulation</h4><p>There are two goals of our benchmarking system: to produce a meaningful complex network of data that are interrelated with each other so we can perform meaningful complex queries against it, and to produce comparable benchmarks between two different database technologies. To achieve these goals, <strong>we built an </strong><a href="https://en.wikipedia.org/wiki/Agent-based_model"><strong>agent-based</strong></a><strong> system that simulates the creation of a virtual world</strong>.</p><p>An <em>“agent-based”</em> system is a simulation that uses a <em>“micro-scale model”</em> to simulate concurrent operations and interactions of multiple low-level <em>“agents”</em> in an attempt to recreate and imitate a high-level, complex phenomenon. In our case, the complex phenomenon we’re simulating is the world: people are born in cities, cities are located in countries, people getting married, people going to school, people going to work at companies, companies created in countries, and so on. Each agent will take on a single one of these tasks, not knowing any other agents and the broader scope of the simulation system. As each agent runs in parallel over multiple iterations, <strong>complex networks of entities and relations emerge in the graph produced by the simulation</strong>.</p><p>The simulation allows us to control the density of interrelationships, as well as the number of iterations it will run to. This gives us control over the scale we want to benchmark. The agent-based model also allows us to curate a diverse set of database operations, used to implement different agents, <strong>ensuring we test as many features of the database being benchmarked as we can</strong>. But most importantly, the agents form a higher-level abstraction of responsibility that can be implemented with different database operations, when benchmarking different database technologies. Each of the database operations may not be comparable, like-for-like, across two different database technologies. However, <strong>the performance of one type of agent implemented across two different technologies remains directly comparable</strong>.</p><h4>13) New <a href="https://grabl.io/">Grabl</a> CI/CD: replacing <a href="https://circleci.com/">CircleCI</a></h4><p>Since the end of 2018, we were already vigilant in ensuring everything that can be tested or automated in CI/CD, would be tested or automated in CI/CD. By the end of 2019, we ended up with an end-to-end CI/CD pipeline on <a href="https://circleci.com/">CircleCI</a>, covering everything from unit tests, integration tests, assembly tests and deployment tests, to release verification and deployment. <strong>However, this came with a lot of infrastructure complexity.</strong> We had servers in <a href="https://heroku.com/">Heroku</a> to coordinate the CD workflow on CircleCI — it was kind of a hack that CircleCI was not meant to do. We had static-code analysis done on <a href="https://sonarcloud.io/">SonarCloud</a>, and lots of scripts in Heroku to automate triaging issues on <a href="https://github.com/">GitHub</a>. We had a server to automate the upgrading of repository dependencies, and a server to run benchmarking jobs in the cloud. We had to use <a href="https://zipkin.io/">Zipkin</a> to do performance tracing, and used <a href="https://www.elastic.co/">ElasticSearch</a> to store and visualise the benchmarking data. We were manually running benchmarking jobs in <a href="https://cloud.google.com/">Google Cloud</a>, and automating the benchmarking of multiple servers as a cluster was not an option. Managing credentials across all these platforms was also a nightmare.</p><p>However, all these tasks are common to engineering teams building any substantially complex system. <strong>Why are they not automated by one system? And that’s how </strong><a href="https://grabl.io/"><strong>Grabl</strong></a><strong> was born.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D_77FQHbg1DQEKw0.png" /></figure><p>First and foremost, <strong>Grabl is built to automate the workflow of the Grakn Labs engineering team</strong> (hence the name: <em>“Grakn’s Builder”</em>). This is the sole focus of Grabl for now, even though we see Grabl being <strong>applicable to any software engineering team</strong> in the future. We wanted a system that was beyond CI/CD; we wanted a system that covers the entire spectrum of the software development lifecycle, which includes teams building distributed systems and work across multiple repositories.</p><p>So for starters, we built Grabl to automate two types of pipelines: [7]</p><ul><li><strong>Build pipeline:</strong> to automate workflows for every “build” of the source code. This pipeline will run for every commit on a repository.</li><li><strong>Release pipeline:</strong> to automate workflows for every “release” of the repository. This pipeline can be triggered at the end of a build pipeline of every commit, if the “verification” workflow passes.</li></ul><blockquote><em>[7] </em>Soon there will be a third pipeline: a <strong>“sync dependencies” pipeline</strong>, that will automate the job of upgrading every repository whenever there’s a (valid and) new version of a dependency. This will propagate automated upgrades from one repository to another across the organisation.</blockquote><p>The <strong>build pipeline</strong> is comprised of three workflows:</p><ul><li><strong>Quality workflow:</strong> automate jobs that produce source code analysis data, and does not affect the correctness of the build. For example, we automate the SonarCloud source code analysis job in this workflow, as well as our “dependency analysis” job to evaluate whether our dependencies are up-to-date.</li><li><strong>Correctness workflow:</strong> automate typical CI jobs that determine the correctness of the source code, a.k.a. <em>tests</em>: unit tests, integration tests, assembly tests, deployment tests, and so on. Only jobs in this workflow will update the commit status on GitHub.</li><li><strong>Performance workflow:</strong> automate jobs that run benchmarks. These jobs tend to be long-running, depend on each other, interact with one another, and produce benchmarking data.</li></ul><p><strong>With a single commit that you push to GitHub</strong>, we analyse the quality of our codebase, run all the tests that determine the correctness, produce benchmarking data to analyse performance. There’s zero developer intervention in between.</p><p>The <strong>release pipeline</strong> is comprised of three workflows:</p><ul><li><strong>Validation workflow:</strong> automate jobs to verify whether a commit can be a valid release candidate. This workflow runs on every commit. If this workflow and the build pipeline passes, the release button will be enabled for admins to trigger.</li><li><strong>Deployment workflow:</strong> automate the jobs of deploying the software to the distribution platforms.</li><li><strong>Broadcast workflow:</strong> automate the jobs of updating systems in your ecosystem of the new release you have just completed.</li></ul><p><strong>Every single commit you push to GitHub can be a valid release candidate</strong>, if the validation workflow says so. <strong>With a single click of approval</strong>, the release deployment and broadcasting runs.</p><p>A <strong>job</strong> is a unit of work that the user defines by providing the “command” script, and parameters to configure the virtual machine it will run on. There can be <em>“foreground”</em> or <em>“background”</em> jobs. The jobs can depend on each other, be aware of each other’s IP address, and can interact with one another. You can also configure the images and resources of the virtual machine that runs the job.</p><p>We designed the UX of Grabl such that jobs, workflows, and pipelines are easily monitored across all repositories in an organisation, and all pages are updated in real-time as the automation runs in the cloud. <strong>This level of organisation-wide visibility was key</strong> to the vision of how we want Grabl to serve our team.</p><p>We also built a <strong>performance tracing system</strong> into Grabl, and the <strong>UI to visualise the benchmarking data</strong>. We can analyse the <em>“traces”</em> of performance benchmarking tasks, nested hierarchy among themselves, macro-level statistical patterns of the benchmarks, micro-level data of each operation, comparisons between 2 commits, and even comparisons between benchmarks of two different database technologies. <strong>You’ll get to see more of Grabl Benchmarking features as we publish Grakn 2.0.0 benchmarking reports in the near future.</strong></p><p>It’s still early days for Grabl, but we now have a platform that can encompass the entire spectrum of the software development lifecycle, and we can extend it to automate anything that we want at Grakn Labs.</p><p>Beyond all the features we’ve mentioned, there’s one more key point that makes Grabl vital: <strong>Grabl is built entirely using Grakn</strong>. It is our very own power-user of Grakn that we developed ourselves, and it serves a key purpose in our team: <strong>Grabl puts us in the shoes of our users developing with Grakn</strong>, and creates a strong feedback loop to Grakn’s core development.</p><p>That just about summarises 2020 for our engineering team at Grakn Labs. We are truly proud of the tremendous work that the team has accomplished, and we’re hugely thankful for the support of everyone in our community. We hope everyone is excited for what Grakn 2.0 will deliver to all of us this year.</p><p>Stay tuned for Grakn 2.0.0 production release very soon, and then our benchmark reports soon after.</p><p><strong><em>Onwards and Upwards!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=960da9a9bc44" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/grakn-2-0-alpha-best-practices-of-distributed-systems-and-computer-science-960da9a9bc44">Grakn 2.0 Alpha: best practices of Distributed Systems and Computer Science</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grakn Labs 2017 Spring Round-up]]></title>
            <link>https://medium.com/vaticle/grakn-ai-2017-spring-round-up-26c10c84e13e?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/26c10c84e13e</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Thu, 20 Apr 2017 15:34:11 GMT</pubDate>
            <atom:updated>2022-03-31T10:30:25.654Z</atom:updated>
            <content:encoded><![CDATA[<h4>Awesome things have been happening at Grakn Labs</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Y_itzYNabqS6iJo7.png" /></figure><p>Spring has arrived! I feel like it has been ages since I wrote about <a href="https://blog.grakn.ai/grakn-2016-year-in-review-e30b66adece3">our year in 2016</a>. But, no, it’s only been less than four months! Nevertheless, so much has happened at <a href="http://www.vaticle.com/">Grakn Labs</a>! So I would like to update you on all the exciting things that have been happening at Grakn Labs, which I also sent to many of you through our biggest round-up newsletter to date!</p><blockquote>Missed our newsletter? You should <a href="http://www.vaticle.com/discord">sign up</a> at <a href="http://www.vaticle.com/discord">grakn.ai/community</a></blockquote><p>We’ve been working hard on building and improving Grakn from all your feedback and requests. We’ve now released version 0.12: a simpler, faster and smarter Grakn and we’ve discussed our novel approach for <em>Modelling Data with Hypergraphs</em>, in contrast to other ontology languages <em>(*cough: OWL*).</em></p><p>Alongside the work we’ve been doing on the technology stack, we’ve also:</p><ul><li>been awarded Product of the Year 2017 by the University of Cambridge</li><li>joined Startup Grind’s prestigious Top 50 Startups</li><li>exhibited at Dublin Tech Summit</li><li>shared our work with IBM Watson team at their HQ in upstate New York</li><li>gave talks at Data Day Texas and IBM InterConnect Las Vegas</li><li>we’re bringing Grakn to Google, IBM and Oracle Cloud</li><li>joined forces with Google, Hortonworks, and IBM on launching JanusGraph</li><li>started the Opensource Graph Technology Meetup community</li><li>joined DZone as most valued bloggers</li><li>passed 2K user downloads, and the community is continuing to grow.</li></ul><p><strong><em>Read on as we share our exciting news with you in detail!</em></strong><br>PS: If you didn’t catch up with our work last year, you might find our <a href="https://blog.grakn.ai/grakn-2016-year-in-review-e30b66adece3">2016 year in review</a> interesting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*g1DUCuB58EiTw3yD.jpg" /></figure><h4><strong>Cambridge Computer Lab Ring: Product of the Year 2017</strong></h4><p>On Wednesday 5th of April, it was the 13th annual dinner of the University of Cambridge Computer Lab Ring — an association of 255 technology companies founded by Cambridge alumni, which includes <a href="http://www.arm.com/">ARM</a>, <a href="https://www.sophos.com/">Sophos</a>, <a href="https://swiftkey.com/">SwiftKey</a>, <a href="https://www.raspberrypi.org/">Raspberry Pi</a>, <a href="https://improbable.io/">Improbable</a>, and <a href="https://deepmind.com/">Google DeepMind</a>. Towards the end of the of the event, we were pleasantly surprised that the Cambridge Computer Lab Ring <a href="https://blog.grakn.ai/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55">Product of the Year 2017 was awarded to Grakn Labs for Grakn</a>. <a href="https://blog.grakn.ai/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55">[Read more]</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ezuRi8u2z6wM7huE.png" /></figure><h4><strong>Grakn 0.12: Simpler, Faster &amp; Smarter!</strong></h4><p>A new release (0.12.0) is available to <a href="http://www.vaticle.com/">download</a> from the usual place. You can find out about the details of the release from the <a href="https://github.com/graknlabs/grakn/releases/tag/v0.12.0">release notes</a>. In summary: we’ve made Grakn <em>simpler</em> with shorter and better syntax; <em>faster</em> by optimising the querying algorithm, reasoning algorithm, analytics computation, indexing strategy, and the underlying engine; and<em> smarter</em> by improving the UX on the visualisation dashboard, more fluent Java APIs, as well as the native reasoning capability to provide an <em>explanation</em> for the inferred results you have queried — <em>we’re breaching new territories that database query languages have not visited before! </em>[<a href="http://www.vaticle.com/">Install</a>]</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*cvjhSDQeOFWfev01.jpg" /></figure><h4><strong>Modelling Data with Hypergraphs</strong></h4><p>We are often asked how Grakn’s ontology contrasts with traditional ontology languages and tools in the <a href="https://en.wikipedia.org/wiki/Resource_Description_Framework">RDF</a>/<a href="https://en.wikipedia.org/wiki/Web_Ontology_Language">OWL</a> world. We have previously touched upon <a href="https://blog.grakn.ai/knowledge-graph-representation-grakn-ai-or-owl-506065bd3f24">why we built our own</a> knowledge representation — in short: <strong><em>RDF &amp; OWL are for the semantic web (not databases) and logicians (not software engineers)</em></strong>. Recently, we also dove in a little deeper and discussed the practicality of Grakn’s ontology: <a href="https://blog.grakn.ai/the-grakn-ai-ontology-simplicity-and-maintainability-ab78340f5ff6">simplicity and maintainability</a>. And now, we share with you the engineering leap we took in the foundation of our work: <a href="https://blog.grakn.ai/modelling-data-with-hypergraphs-edff1e12edf0"><em>Modelling Data with Hypergraphs</em></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Y_itzYNabqS6iJo7.png" /></figure><h4><strong>Taking Distributed Knowledge-Bases to the Clouds!</strong></h4><p>At Grakn Labs, we all believe that cloud computing is the future of computing infrastructures. We are very excited by the opportunity to <a href="https://blog.grakn.ai/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55">partner with Google Cloud</a> at this point in the growth of our product, to provide services to our clients that leverage both the scaling capabilities of Google and intelligence of Grakn.<br>We’re also in the process of the deploying Grakn on <a href="https://cloud.oracle.com/">Oracle Cloud</a> and <a href="https://www.ibm.com/cloud-computing/bluemix/">IBM Bluemix</a>, so stay tuned for updates. By the end of this year, we plan to provide Grakn as a service on all leading cloud infrastructures for you to easily integrate with your applications. <a href="https://blog.grakn.ai/grakn-ai-on-google-cloud-f18f6692670c">[Read more]</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q-EFLT2SOmTWAdde.png" /></figure><h4><strong>Opensource Graph Technology: Monthly Meetups</strong></h4><p>In January, <a href="https://blog.grakn.ai/janus-launch-22be6ac3b197">we announced our collaboration</a> with <a href="https://experoinc.com/">Expero</a>, <a href="https://google.com/">Google</a>, <a href="https://hortonworks.com/">Hortonworks</a> and <a href="https://www.ibm.com/">IBM</a> on <a href="https://blog.grakn.ai/janus-launch-22be6ac3b197">JanusGraph</a>. We co-organised a <a href="https://developer.ibm.com/opentech/2017/03/06/janusgraph-meetups-march-2017-new-york-london/">meetup in New York</a> on JanusGraph in early March, and its success motivated us to start <a href="https://meetup.com/graphs">Opensource Graph Technology</a> Meetup community for learning how open source graph technologies work with highly interconnected and complex data. The London <a href="https://blog.grakn.ai/opensource-graph-technologies-meetup-9a1f15c60109">inaugural meetup</a> in mid-March was a success, and we look forward to seeing all you the next one: <a href="https://www.meetup.com/graphs/events/238564100/">Applications Built with Graphs</a>, on the 2nd of May. <a href="https://www.meetup.com/graphs/">[Go to Meetup]</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/0*9sw4EHgKDKFaKFBo.jpg" /></figure><h4><strong>We were one of the World’s Top 50 Startups!</strong></h4><p>Since the beginning of this year, we’ve spent many weeks on the road. We presented our work at <a href="https://blog.grakn.ai/grakn-ai-at-data-day-texas-2017-269ffba603b5">Data Day Texas 2017</a>; we exhibited at the <a href="https://blog.grakn.ai/grakn-ing-around-an-ai-startup-on-the-road-in-2017-f8fedb185b08">AIBE Summit</a>, <a href="https://blog.grakn.ai/grakn-ing-around-an-ai-startup-on-the-road-in-2017-f8fedb185b08">WSDM Cambridge</a> and <a href="https://blog.grakn.ai/grakn-ai-on-the-road-7a0610b988e0">Dublin Tech Summit</a>; and <a href="https://blog.grakn.ai/grakn-ai-on-the-road-7a0610b988e0">we held talks</a> at ThoughtWorks, as well as IBM Watson’s massive and historical HQ in upstate New York. It was a tiring couple of months, but it was truly an amazing experience which highlights a tremendous milestone of our journey, as one of the events towards the end our trip was to attend <a href="https://blog.grakn.ai/grakn-ai-is-a-top-50-startup-d5ce01c2af9a">Startup Grind Global Conference in San Francisco</a>. With over 6000 companies in the running this year, from 200 cities in 80 countries around the world, the Grakn Labs team was incredibly excited and truly honoured to be selected as the world’s Top 50 most impressive and elite companies who will join Startup Grind’s 2017 Global Startup Program. <a href="https://blog.grakn.ai/grakn-ai-is-a-top-50-startup-d5ce01c2af9a">[Read more]</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*fMqETtcVPmVISugY.png" /></figure><blockquote>In case you missed the talks that Haikal has been giving in the past few months, you can catch up with his core message in this video from February’s Data Day Texas 2017.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*V-AIaQ5dTXtXJx1K.png" /></figure><p><strong>2200+ Downloads, 100+ members, 500+ followers, and counting!</strong><br>We know it’s still early days, but we can’t be more enthusiastic to see the growth and support of our community. By this 0.12 release, Grakn has been downloaded 2200 times, we’ve got more than 100 community members active in on our community <a href="https://medium.com/www.vaticle.com/discord">Slack</a> channel and <a href="https://discuss.grakn.ai/">discussion forum</a>, and we’ve reached 500 Twitter followers. We’re very thankful for the support and feedback from all of you in our community — we continue to improve because of you. And for those of you who haven’t joined, we’d like to invite you to be part of our <a href="http://www.vaticle.com/discord">developer community</a>!</p><p>We’ve heard so many of you are developing amazing things on Grakn. So starting next month, <strong><em>we would like to write about your work and feature it on our blog. </em></strong>So if you’d like to be featured, give us a shout on <a href="https://twitter.com/graknlabs">@GraknLabs</a>, shoot us a message on <a href="http://www.vaticle.com/discord">Slac</a>k, or write to us at <a href="/service/mailto:community@grakn.ai?subject=I%27d%20like%20to%20be%20featured%20on%20Grakn%20Blog!">community@grakn.ai</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bw4Er0MDCXtnoQ-I.png" /></figure><p><strong>Last but not least, there’s so much more on our blog!</strong><br>We are pleased to announce that we have been invited to blog over on <a href="http://dzone.com/">DZone</a>. Some of our posts have already gone live, and we look forward to working with the DZone team in future to syndicate our very best content onto their zones. Speaking of which, over on the blog in the last few weeks, we have published some very cool articles covering a range of topics:</p><ul><li><a href="https://blog.grakn.ai/modelling-data-with-hypergraphs-edff1e12edf0">Modelling Data with Hypergraphs</a></li><li><a href="https://blog.grakn.ai/the-grakn-ai-ontology-simplicity-and-maintainability-ab78340f5ff6">The GRAKN.AI Ontology: Simplicity and Maintainability</a></li><li><a href="https://blog.grakn.ai/grakn-ai-q-a-episode-1-33455f9549c8">GRAKN.AI Q&amp;A: Episode 1</a></li><li><a href="https://blog.grakn.ai/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55">Cambridge Computer Lab Ring: Product of the Year goes to GRAKN.AI</a></li><li><a href="https://blog.grakn.ai/what-is-ai-ingredients-for-intelligence-f11a51403df3">What is AI? A layperson’s guide to the ingredients for intelligence</a></li><li><a href="https://blog.grakn.ai/what-is-an-ontology-c5baac4a2f6c?source=collection_detail----60f79844688a-----6-----------">What is an Ontology?</a></li><li><a href="https://blog.grakn.ai/working-with-grakn-ai-using-java-5f13f24f1269">Learn GRAKN with Java</a></li><li><a href="https://blog.grakn.ai/https-blog-grakn-ai-trumpworld-making-a-knowledge-graph-a0fa27c57325?source=collection_detail----60f79844688a-----8-----------">TrumpWorld: Making a Knowledge Graph</a></li><li><a href="https://blog.grakn.ai/opensource-graph-technologies-meetup-9a1f15c60109?source=collection_detail----60f79844688a-----1-----------">Opensource Graph Technologies: Inaugural Event</a></li><li><a href="https://blog.grakn.ai/grakn-ai-on-google-cloud-f18f6692670c?source=collection_detail----60f79844688a-----2-----------">GRAKN on Google Cloud</a></li><li><a href="https://blog.grakn.ai/chatbots-and-grakn-ai-67563c64cfde">Building Chatbots with API.AI and GRAKN LABS</a></li><li><a href="https://blog.grakn.ai/grakn-ai-and-haskell-c166c7cc1d23">GRAKN LABS and Haskell</a></li><li><a href="https://blog.grakn.ai/grakn-ai-at-data-day-texas-2017-269ffba603b5">GRAKN LABS at Data Day Texas 2017</a></li><li><a href="https://blog.grakn.ai/janus-launch-22be6ac3b197">GRAKN LABS Announces Collaboration with Expero, Google, Hortonworks and IBM on JanusGraph</a></li><li><a href="https://blog.grakn.ai/grakn-2016-year-in-review-e30b66adece3">GRAKN LABS 2016: Year in Review</a></li></ul><p><em>So that’s what we were busy with this past winter. I hope you enjoyed catching up with all the things we’ve done. Stay tuned for more updates in the Autumn!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26c10c84e13e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/grakn-ai-2017-spring-round-up-26c10c84e13e">Grakn Labs 2017 Spring Round-up</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Grakn Ontology: Simplicity and Maintainability]]></title>
            <link>https://medium.com/vaticle/the-grakn-ai-ontology-simplicity-and-maintainability-ab78340f5ff6?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab78340f5ff6</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Sat, 15 Apr 2017 13:36:09 GMT</pubDate>
            <atom:updated>2020-03-10T16:16:56.265Z</atom:updated>
            <content:encoded><![CDATA[<h4>In comparison with traditional ontology languages and tools</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SGV9ohHdbhM-nn5q." /></figure><p><em>Grakn is a distributed knowledge graph with a reasoning query language that enables you to query for explicitly stored data and implicitly derived information. Learn more at</em><a href="https://grakn.ai/"><em> grakn.ai</em></a><em>.</em></p><p>Technology is invented for solving difficult problems in this world. The shape or form in which it is delivered is almost irrelevant, and should not get in the way of its potential purpose. Ontology systems are an example; it is a technology that humans invented to solve difficult problems in the field of information science. At Grakn Labs, we provide an ontology language for you to model your knowledge graph.</p><p>However, the current ontology languages and tools (<a href="https://en.wikipedia.org/wiki/Resource_Description_Framework">RDF</a>/<a href="https://en.wikipedia.org/wiki/Web_Ontology_Language">OWL</a>) have never made it practical for engineers to implement, and so they have mainly stayed in the research space for a long time. At<a href="https://grakn.ai/"> Grakn Labs</a>, our core mission is to make knowledge graphs and ontologies easy to use for engineers to use for the first time. We want engineers to be able to develop their knowledge graphs rapidly and update their data model frequently. This way, their data platform can continue to evolve as the business grows, and immediately reap the real benefit of a knowledge graphs:</p><blockquote>To enable machines to <strong>reason and infer hidden knowledge</strong> that is too complex for human cognition to uncover.</blockquote><p>As you can imagine, we are often asked how Grakn contrasts with traditional ontology languages and tools in the RDF/OWL world. We have previously touched upon<a href="https://blog.grakn.ai/knowledge-graph-representation-grakn-ai-or-owl-506065bd3f24"> why we implemented our own knowledge representation model</a>. To put it short:</p><blockquote><strong>RDF &amp; OWL are for semantic web (not databases) and logicians (not software engineers). </strong>And Grakn, as you may expect, is for databases and software engineers.</blockquote><p>This time we thought to dive in a little deeper and discuss the practicality of Grakn’s ontology. We believe that the language we provide, Graql, is simple and maintainable for software engineers to use as their <em>de facto</em> data/development platform.</p><h3>Simplicity</h3><blockquote>Everything should be made as simple as possible, but not simpler. — Albert Einstein</blockquote><p><strong>Simple and intuitive syntax</strong></p><p>Grakn has an intuitive<a href="https://blog.grakn.ai/what-is-an-ontology-c5baac4a2f6c"> ontology</a> language, Graql, which is the same language used to query the knowledge graph. It has a simple syntax that is not burdened with URIs or complex serialisation of OWL axioms in RDF/XML, Turtle, or N3 formats.</p><p><strong>A Smaller set of higher level modelling constructs</strong></p><p>Compared to OWL, Graql has a<strong> </strong>smaller set of<a href="https://grakn.ai/pages/documentation/the-fundamentals/grakn-knowledge-model.html"> ontology modelling constructs</a>, but can express all the core use cases of complex domain modelling. Graql’s ontology language contains higher level constructs that defines [<em>N-ary</em>] <em>hyper-relations</em> and <em>hyper-objects</em> as basic concepts in the building blocks. This is contrasted with modelling each OWL (data/object) property separately and then combining them into <em>N-ary</em> relation patterns using auxiliary class names and property restrictions. Although OWL offers potentially higher expressivity, it comes at the cost of increased complexity. Crucially, our goal here with Grakn is to model the real world in a straightforward way, and not to burden engineers with additional complexity. Additionally, OWL lacks essential facilities for meta-knowledge and higher-level modelling (nested relations, information about relations, etc.) which consequently makes it more complicated to work with.</p><p><strong>Familiar OOP principle</strong></p><p>Grakn’s modelling principle is based on the familiar<strong> </strong>object-oriented<strong> </strong>software engineering principles, which are well known to software engineers, and integrated within the general software development process. This is a significant distinction to the modelling principle of OWL, which is deeply rooted in pure<a href="https://en.wikipedia.org/wiki/Mathematical_logic"> formal logic</a>. In effect, Grakn provides developers necessary tools to build intelligent systems, without requiring familiarity with the minutiae of complex formalisms (as we abstract it deep in the underlying system).</p><h3>Maintainability</h3><blockquote>By virtue of its <strong>simplicity</strong>, a Grakn ontology is easier to maintain than more complex ontologies written in RDF/OWL, but that’s not all we got to offer.</blockquote><p><strong>Flexible and scalable schema</strong></p><p>Grakn’s ontology is flexible and can be updated at any point in the lifecycle of the database, even when you have terabytes of data. The knowledge representation model takes into account future changes as much as possible, in such a way that addition of new data types to the ontology does not break existing ontology definitions. For example, your data model may need to accommodate new entity, attribute and relation types in varying orders and combinations after data was already loaded to the database, that can all be easily done in our ontology without breaking your existing model. Thus, Grakn allows the data model to evolve with the business model, even when there is lots of data, building a lasting advantage as your business grows and learns.</p><p><strong>Abundant modelling expertise</strong></p><p>As noted above, having a modelling principle based on OOP makes Grakn more developer-oriented and it can be easily adopted by any engineer. On the other hand, there is a substantial discrepancy between OWL and conventional OOP modelling principles; OWL requires a deep expertise in formal logic systems. Modelling in RDF/OWL often requires a PhD to simplify the ontology as they come up with notions of ontology patterns.</p><p><strong>Fully integrated environment</strong></p><p>Grakn is a fully integrated knowledge-base environment, which has storage, querying, validation, reasoning, IDE (in progress), visualisation and discovery (in progress) all in one system where the user does not need to care about integrations. RDF/OWL platforms require complex layers of loosely coupled components from many different systems, such as ontology editors (e.g. Protege), storage (RDF triple stores), query engines (e.g. SPARQL), reasoners (e.g. Pellet, other OWL reasoners).</p><p><strong>Automated validation and reasoning</strong></p><p>Given an ontology, Grakn automatically takes care of validating input data in real-time, and reasoning/inference is a native behaviour of the Graql language. You immediately reap the validation and reasoning benefits of the ontology. It is not as straightforward in the RDF/OWL world; validation does not happen in real-time and reasoners are not naturally integrated. Validation is thus a slow, off-line computation and reasoning requires integration of separate reasoner-tools with your SPARQL query language, which is not always seamless, often very buggy, and does not scale.</p><h3>Why are Schema-Constraints Necessary?</h3><blockquote>Grakn’s ontology is basically an intelligent<a href="https://en.wikipedia.org/wiki/Type_system"> type system</a> for your complex data.</blockquote><p>A complex relationship model combined with no data schema-constraint means that there are an exponential number of possible mistakes. Thus, one of value propositions of Grakn’s ontology is that it functions as a schema constraint to your data, which gets validated in real-time upon writing it to the database.</p><p>If a database does not have any form of schema-constraint, the application layer code is instead burdened with the responsibility of maintaining data consistency and logical integrity. The application layer then becomes bloated with complex business logic, to facilitate the process of query abstractions and interpretations.</p><p>There is a debate in the programming world about the virtues of<a href="https://en.wikipedia.org/wiki/Strong_and_weak_typing"> strongly-typed and loosely-typed languages</a>. Loosely-typed languages, e.g. javascript, are easy to start coding and give no compiler errors. Similarly, it is easy to start with a database that has no-schema constraint, and ingest data quickly. But as the system grows, you end up needing<a href="https://en.wikipedia.org/wiki/Type_system"> <em>type systems</em></a>, so that you won’t always crash because of incorrect assumptions about data types. Grakn’s ontology is basically a highly expressive and intelligent <em>type system </em>for your complex data, which reduces the complexity of your code by ensuring a higher degree of data integrity, consistency, and consequently, quality.</p><h3>Summary</h3><p>In this article, we have presented the reasons why we believe Grakn is simple to use and easy to maintain when compared to traditional ontology languages and tools in the RDF/OWL world, which include:</p><ul><li>simple and intuitive<a href="https://blog.grakn.ai/what-is-an-ontology-c5baac4a2f6c"> ontology</a> and query language</li><li>smaller set of higher level<a href="https://grakn.ai/pages/documentation/the-fundamentals/grakn-knowledge-model.html"> modelling constructs</a></li><li>familiar Object-Oriented software engineering principles</li><li>flexible and scalable data model</li><li>fully integrated knowledge-base environment</li><li>real-time validation and native reasoning</li></ul><h3>Where can I find out more?</h3><p>To find out more, take a look at our<a href="https://grakn.ai/pages/index.html"> documentation</a> — the<a href="https://grakn.ai/pages/documentation/the-fundamentals/grakn-knowledge-model.html"> Knowledge Model</a> documentation is a good place to start for more about the subjects touched upon above.</p><p>And if you have any questions, we are always happy to help. A good way to ask questions is via our<a href="https://grakn.ai/slack.html"> Slack</a> channel. We also have a<a href="https://discuss.grakn.ai/"> discussion forum</a>. For news, sign up for our<a href="https://grakn.ai/community.html"> community newsletter</a> and — if you’d like to meet us in person — we run regular<a href="https://www.meetup.com/graphs/"> meetups</a>.</p><p>Thanks<a href="https://medium.com/u/49dd0198b639"> Jo</a> for helping me revising the text!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab78340f5ff6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/the-grakn-ai-ontology-simplicity-and-maintainability-ab78340f5ff6">The Grakn Ontology: Simplicity and Maintainability</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grakn Labs Q&A: Episode 1]]></title>
            <link>https://medium.com/vaticle/grakn-ai-q-a-episode-1-33455f9549c8?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/33455f9549c8</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Fri, 07 Apr 2017 16:48:28 GMT</pubDate>
            <atom:updated>2020-03-10T16:07:02.195Z</atom:updated>
            <content:encoded><![CDATA[<h4>Some frequently asked questions about the database for AI</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xnjCWg1wOdhI5dAZrZzf2w.jpeg" /></figure><p><strong><em>OK then. What is Grakn?</em></strong></p><p><a href="https://grakn.ai/">Grakn</a> is a distributed <a href="https://en.wikipedia.org/wiki/Knowledge_base">knowledge base</a> (Grakn) with a <em>reasoning </em>query language (Graql) that enables querying for explicitly stored data and implicitly derived information.</p><p>Grakn uses an intuitive <a href="https://www.google.co.uk/url?sa=t&amp;rct=j&amp;q=&amp;esrc=s&amp;source=web&amp;cd=1&amp;cad=rja&amp;uact=8&amp;ved=0ahUKEwjW2sPJtY3TAhWrIcAKHQq0D7QQFggcMAA&amp;url=https%3A%2F%2Fblog.grakn.ai%2Fwhat-is-an-ontology-c5baac4a2f6c&amp;usg=AFQjCNEiN_b-2Y6fKHe_aiVcNWLLVP9Yig&amp;sig2=roEL6sqclo0xAI8PPpLcAg&amp;bvm=bv.151426398,d.ZGg">ontology</a> as a data model that allows you to define a set of types, properties, and relationship types. The ontology allows you to model extremely complex datasets, and functions as a data schema constraint to guarantee data consistency, i.e. <a href="https://en.wikipedia.org/wiki/Data_integrity">logical integrity</a>. The ontology modelling constructs include type hierarchies, n-ary relationships, and higher-order modelling constructs. <strong><em>Grakn allows you to model the real world and all the hierarchies and hyper-relationships contained within it.</em></strong></p><p>Grakn is built using several graph computing and distributed computing platforms, such as <a href="https://tinkerpop.apache.org/">Apache TinkerPop</a> and <a href="http://spark.apache.org/">Apache Spark</a> and is designed to be sharded and replicated over a network of distributed machines. Internally, it stores data in a way that allows machines to understand the meaning of information in the complete context of their relationships. Consequently, Grakn allows computers to process complex information more intelligently, with less human intervention.</p><p>Graql is a <a href="https://en.wikipedia.org/wiki/Declarative_programming">declarative</a>, knowledge-oriented graph query language that uses machine reasoning to retrieve explicitly stored and implicitly derived information from Grakn. On other database systems, queries have to define the data patterns they are looking for explicitly. Graql, on the other hand, will translate a query pattern into all its logical equivalents and execute them against the database. This includes the inference of types, relationships, context, and pattern combination.</p><p>Graql allows you to derive implicit information that is hidden in your dataset and makes finding new knowledge easy.</p><p>In combination, Grakn and Graql are what makes Grakn Labs, the knowledge base for working with complex data.</p><p><strong><em>Can you explain Grakn Lab’s “ontology-first” model?</em></strong></p><p>In Grakn, the <a href="https://blog.grakn.ai/what-is-an-ontology-c5baac4a2f6c">ontology</a> is the formal specification of all the relevant concepts and their meaningful associations in a given domain. It allows objects and relationships to be categorised into distinct types, and for generic properties of those types to be expressed. Specifying the ontology enables <a href="https://en.wikipedia.org/wiki/Inference_engine">automated reasoning</a> over the <a href="https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning">represented knowledge</a>, such as the extraction of implicit information from explicit data or discovery of inconsistencies in the data. For this reason, the ontology(<a href="http://dev.grakn.ai/docs/schema/overview">schema</a>) must be clearly defined before loading data into the graph.</p><p><strong><em>Won’t that cause extra complexity?</em></strong></p><p>We don’t think so! To model the world accurately, you need to model type hierarchies, since without that level of representation, you cannot interpret data or knowledge accurately, and you cannot build a model that is easily extensible. On Grakn, since the type system exists in the ontology rather than in the data, you have control over what goes into the model. Wild streams of input data cannot mess up the model, and type definitions can only go out of control if you <strong><em>explicitly</em></strong> mess up the ontology. You face fewer hurdles when ingesting your data and you spend less time and effort on data cleanup and integration.</p><p>If you didn’t model your data in an ontology, you would have to do it in your system application layer. But modelling your data domain within code is difficult, hard to scale, maintain and extend. Our approach allows you to keep your data model and code separate.</p><p><strong><em>What are the advantages compared to relational schema?</em></strong></p><p>Grakn’s ontology modelling approach differs from relational schema because:</p><ul><li>It can model type hierarchies.</li><li>It can model hyper-relationships, such as relations in relations, N-ary relations, and virtual relations.</li><li>It can be updated easily even after you’ve added data.</li><li>It provides more granular access control at a single type level.</li><li>It is interpretable by a computer/reasoner, such that querying can infer relationships and can compress complex queries.</li></ul><p>If you model your relationships in a relational schema, it doesn’t mean that you can query long sequences of relationships since the <strong><em>sql-joins</em></strong> involved would severely impact performance.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPLDaQNzoeb9L7UZDPq7z1Gd2Rc0m_oeSDQ&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DOeFrudRlXAM&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FOeFrudRlXAM%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/73f300071664831fb3710cf32a1591ae/href">https://medium.com/media/73f300071664831fb3710cf32a1591ae/href</a></iframe><p><strong><em>Isn’t it limiting to have to model data before it is ingested? I’m sure my data will change.</em></strong></p><p>If you have new data that requires a new model, which you have not considered before, then, yes, you will need to extend your ontology. However, Grakn’s ontology/data model:</p><ul><li>is as robust as relational schemas.</li><li>is as easy to extend/update as adding in data. It gives you more control over new data models that go into your system and maintains higher quality data.</li><li>allows you to retain logical integrity of your data, which is one of the purposes of the ontology.</li><li>can be circumvented if you want to. You can still add data that doesn’t fit your ontology, by creating a generic entity-relationship-resource model to ingest general information that doesn’t have any particular type. Imagine it to be “an abstract type”, but not really “abstract”. You will still get the benefit of having an intelligent and simple query language, but you won’t get the benefit of deep/advance inference.</li><li>allows you to ask previously unimagined questions about the data because the ontology provides a reasoning model for the query language to interpret future questions in the most flexible and expressive manner. Without the ontology, you would be limited in this respect.</li></ul><p><strong><em>Is it practical to have to define an ontology before I’ve worked with the data? Why can’t I just put it into a graph as a set of entities and relationships?</em></strong></p><p>In the past, it hasn’t been practical with other technologies that use an ontology, but that is the main mission for us at Grakn Labs: to make <a href="https://blog.grakn.ai/what-is-an-ontology-c5baac4a2f6c">ontologies</a> and <a href="https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning">knowledge representation</a> practical for the very first time, by integrating seamlessly with a database. Our goal is to ensure that users don’t worry about perceived <em>“baggage”</em>, but simply get expressive modelling abilities without having to worry about how to implement data structure and constraints.</p><p>And yes, you could just use a graph database, but with Grakn, your data sits in a knowledge base, which enables automation, pattern matching, inference and discovery with very little human intervention. You can uncover hidden patterns in the data that are too complex for human cognition.</p><p><strong><em>How can I visualise my data?</em></strong></p><p><a href="http://dev.grakn.ai/docs/workbase/overview">Grakn Workbase</a> is a relatively new addition to our platform, and has only been in development for several months. It allows you to view a portion of your dataset, by filtering it using Graql queries.</p><p>We’re committed to extending our UI over the years to come. This year alone, we plan to collaborate with other technologies in the industry on building a WebGL-based graph visualiser, which uses the GPU to render tens of thousands of nodes on the screen.</p><p>The visualiser is a way to show relationships structures of specific portions of data, but ultimately is not the final place for users to analyse data. For that kind of work, we’re building a <strong><em>Knowledge Discovery Terminal</em></strong>, allowing users to visualise and analyse their data through different views: tabular, charts, diagrams and custom combinations thereof. Similarly, we’re also developing a <strong><em>Knowledge Development Environment</em></strong> for users to visualise, edit, and develop advanced data models using visual aids.</p><p><strong><em>Can you support a high volume of data?</em></strong></p><p>Cassandra is the distributed database behind Facebook, Netflix, and other giant systems, which says a lot about its scalability. Grakn scales completely horizontally with Cassandra under-the-hood: we shard and replicate data easily, unlike some other graph DBs (<em>wink</em>). We will publish some benchmark data soon!</p><h3>Ask A Question!</h3><p>It’s your turn! What other questions would you like to ask the Grakn Labs team? Please hit us up in the comments below, or via <a href="https://twitter.com/GraknLabs">Twitter</a>.</p><h3>Where can I find out more?</h3><p>To find out more, take a look at our <a href="http://dev.grakn.ai/">documentation</a> — the <a href="http://dev.grakn.ai/docs/schema/overview">Schema</a> documentation is a good place to start for more about the subjects touched upon above.</p><p>And if you have any questions, we are always happy to help. A good way to ask questions is via our <a href="https://grakn.ai/slack.html">Slack</a> channel. We also have a <a href="https://discuss.grakn.ai/">discussion forum</a>. For news, sign up for our <a href="https://grakn.ai/community.html">community newsletter</a> and — if you’d like to meet us in person — we run regular <a href="https://www.meetup.com/graphs/">meetups</a>.</p><p>Thanks <a href="https://medium.com/u/49dd0198b639">Jo</a> for revising the text!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33455f9549c8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/grakn-ai-q-a-episode-1-33455f9549c8">Grakn Labs Q&amp;A: Episode 1</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cambridge Computer Lab Ring: Product of the Year 2017 goes to Grakn Labs]]></title>
            <link>https://medium.com/vaticle/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0d7c5ba9f55</guid>
            <category><![CDATA[awards]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Fri, 07 Apr 2017 15:43:41 GMT</pubDate>
            <atom:updated>2022-03-24T16:24:08.582Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sxpraRmaZoSI6mF-wg69eA.jpeg" /><figcaption>Photo courtesy of Marco Scoppetta</figcaption></figure><p>Four years ago, I sat in an <a href="https://en.wikipedia.org/wiki/Automated_reasoning">Automated Reasoning</a> class, during my studies at the <a href="https://www.cam.ac.uk/">University of Cambridge</a>, and since then I’ve always wondered how amazing it would be to enable computers to reason over data and derive new conclusions for us. And of course, there have been many great minds before us that have pursued this idea and got us much closer to realising this ambition. A couple of years later, I found myself extremely fortunate to be working together with a brilliant team, on exactly this problem. Together, we worked hard to build <a href="http://www.vaticle.com/">Grakn Labs</a>, a distributed knowledge base with a query language that performs automated reasoning over data. Why? To simplify the dimensionality of searching through complex data, and to automate the process.</p><p>A year into our work, we joined the University of Cambridge Computer Lab Ring — an association of 255 technology companies founded by Cambridge alumni, which includes <a href="http://www.arm.com/">ARM</a>, <a href="https://www.sophos.com/">Sophos</a>, <a href="https://swiftkey.com/">SwiftKey</a>, <a href="https://www.raspberrypi.org/">Raspberry Pi</a>, <a href="https://improbable.io/">Improbable</a>, and <a href="https://deepmind.com/">Google DeepMind</a>. It is an honour to be part of this community, as these innovative technology companies from my alma mater have always been a source of inspiration to me.</p><p>On Wednesday evening, it was the Ring’s 13th annual dinner and we were delighted to be attending for the first time. Towards the end of the of the event, we were pleasantly surprised that the <a href="https://www.cl.cam.ac.uk/ring/awards.html">Cambridge Computer Lab Ring Product of the Year 2017</a> was awarded to <a href="http://www.vaticle.com/">Grakn Labs</a> for <a href="http://www.vaticle.com/typedb">Grakn</a>, joining the ranks of companies like SwiftKey and Google DeepMind in the <a href="https://www.cl.cam.ac.uk/ring/awards.html">Ring’s Hall of Fame</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xi32kqaMOQ3CItC8qOKrOg.jpeg" /></figure><p>It’s been an incredibly long journey for us at Grakn Labs, filled with so many ups and downs, and this award serves as a strong reminder for us to keep on pushing forward. Also, since my time as a graduate student the university was seminal to the founding of <a href="http://www.vaticle.com/">Grakn Labs</a>, this award from some of the most distinguished members of the university and alumni has another layer of significance to me.</p><p>I would like to take this opportunity to thank the University of Cambridge, Cambridge Computer Lab Ring, our developer community, and most importantly, the <a href="https://grakn.ai/about">entire Grakn Labs team</a> for all their hard work that got us to this point! This is a tremendous piece of validation for our work that we are truly humbled by and grateful for.</p><p>We look forward to the challenges ahead in the coming year!</p><p>Here at Grakn Labs, we have created a knowledge base so that AI applications have a way to leverage all the data that an intelligent system needs. If you want to find out more about what we do, take a look at our <a href="http://dev.grakn.ai/">documentation</a> and our <a href="https://blog.grakn.ai/">blog</a>, come to our <a href="https://www.meetup.com/graphs/">meetups</a>, join our <a href="https://grakn.ai/community.html">community</a> or leave a comment below.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0d7c5ba9f55" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/cambridge-computer-lab-ring-product-of-the-year-2017-goes-to-grakn-ai-d0d7c5ba9f55">Cambridge Computer Lab Ring: Product of the Year 2017 goes to Grakn Labs</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grakn Labs on Google Cloud]]></title>
            <link>https://medium.com/vaticle/grakn-ai-on-google-cloud-f18f6692670c?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/f18f6692670c</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Fri, 10 Mar 2017 15:58:47 GMT</pubDate>
            <atom:updated>2020-03-10T14:03:45.168Z</atom:updated>
            <content:encoded><![CDATA[<p>Grakn Labs joins the Google Cloud Technology Partner Program</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oNZn3SrkWHkcNj7kyQnXTA.png" /></figure><p><a href="https://grakn.ai/"><strong>Grakn Labs</strong></a> is pleased to announce that we have recently joined the Google Cloud Technology Partner Program to provide Grakn Labs Cloud.</p><p><a href="https://grakn.ai/pages/overview/index.html">Grakn is the database for AI</a>. AI systems need a knowledge base to manage their data because they produce and consume more complex information than average software. Grakn is a database in the form of a distributed knowledge base with a reasoning query language that allows you to model, verify, scale, query and analyse complex data easily. By providing a query language that uses machine reasoning to uncover knowledge too complex for human cognition to infer, <a href="https://grakn.ai/">Grakn Labs</a> allows organisations to grow their competitive advantage, all the while reducing engineering time, cost, and complexity.</p><p><a href="https://cloud.google.com/"><strong>Google Cloud Platform</strong></a> is a <a href="https://en.wikipedia.org/wiki/Cloud_computing">cloud computing</a> service by <a href="https://en.wikipedia.org/wiki/Google">Google</a> that offers hosting on the same supporting infrastructure that Google uses internally for end-user products like <a href="https://en.wikipedia.org/wiki/Google_Search">Google Search</a> and <a href="https://en.wikipedia.org/wiki/YouTube">YouTube</a>. It is the engine behind many innovative cloud solutions, such as Spotify and Feedly.</p><p>We plan to use Grakn Labs Cloud to offer single click provisioning of a scalable Grakn Labs deployment on top of Google Compute Engine — benefiting from <a href="https://medium.com/google-cloud/new-google-cloud-ssds-have-amazing-price-to-performance-2a58e7d9b433#.gpj5yr9wp">super fast SSDs</a> and <a href="https://cloud.google.com/compute/pricing#billingmodel">per-minute pricing</a>. Integrating with Google Dataproc, the <a href="https://hackernoon.com/why-dataproc-googles-managed-hadoop-and-spark-offering-is-a-game-changer-9f0ed183fda3">managed Spark/Hadoop product</a>, Grakn Labs customers will be able to run Analytics on very large scale datasets to crunch big data.</p><p>We are very excited by the opportunity to partner with Google at this point in the growth of our product to provide services to our clients that leverage both the scaling capabilities of Google and intelligence of Grakn.</p><p>We’re also in the process of the deploying Grakn on <a href="https://cloud.oracle.com/">Oracle Cloud</a> and <a href="https://www.ibm.com/cloud-computing/bluemix/">IBM Bluemix</a>, so stay tuned to our updates. By the end of this year, we plan to provide Grakn as a service on all leading cloud infrastructures of the world for you to easily integrate with your applications!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CpWJzo671MM4PZc180E0yA.png" /></figure><h3>About Grakn Labs</h3><p>Headquartered in London, UK, Grakn Labs was founded in 2015, and is privately funded The core product, Grakn Core, is an open-source knowledge graph data platform that uses the power of machine reasoning to support businesses in building cognitive and intelligent systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f18f6692670c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/grakn-ai-on-google-cloud-f18f6692670c">Grakn Labs on Google Cloud</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GRAKN.AI 2016: Year in Review]]></title>
            <link>https://medium.com/vaticle/grakn-2016-year-in-review-e30b66adece3?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/e30b66adece3</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[teamwork]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Sat, 31 Dec 2016 19:39:37 GMT</pubDate>
            <atom:updated>2017-01-29T01:20:21.814Z</atom:updated>
            <content:encoded><![CDATA[<p>It has been a fantastic year for us at <a href="https://grakn.ai/">GRAKN.AI</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ICzfopTHgkgyCj55Vg1afA.png" /><figcaption>GRAKN.AI Team, learn more at <a href="https://grakn.ai/about.html">grakn.ai/about</a></figcaption></figure><p><em>GRAKN.AI is a knowledge graph data platform that uses machine reasoning to simplify complex data processing for AI applications. Learn more at </em><a href="https://grakn.ai/"><em>grakn.ai</em></a></p><p>Our company started in July 2015. So 2016 was the first full year that we experienced as a team, and we cannot be more thankful for the journey that we went through this past year. 2016 was truly an amazing year for all of us at GRAKN.AI, and I hope it has been the same for all of you as well.</p><p>Overall, 2016 has been an incredible growth year for us at GRAKN.AI. We released a prototype application, Moogi: a film discovery engine powered by Grakn. We launched our online platforms: from a chat platform to a discussion forum, a blog and a documentation platform. We grew to a solid team of 17, after reviewing 1400 candidates through a 6stage recruitment process. We scaled our project management framework to manage 18 projects, completing 500 requirements with 9000 work items and 10000 pre-estimated hours. We found our new name that uniquely describes us. We released the Grakn, from 0.1 (Beta) in September all the way to 0.9 (almost production) right before Christmas. We gave plenty of demos to numerous enterprises, and the feedback has been very positive. Last but not least, our open-source community started growing at a rate that exceeded our expectations.</p><p>In this final blog post of the year from us, I will share the work that we have done at GRAKN.AI with all of you, and I would also like to thank everyone involved with the development of our company in whatever way or form. :)</p><p>Enjoy the read as we take you through our 2016 journey …</p><h3>We released a prototype application: <a href="https://moogi.co/">Moogi.co</a></h3><blockquote>We developed a semantic search engine for film discovery powered by Grakn!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*75bX9x3BKUm7EVtCdRysqw.png" /><figcaption>Moogi: The Film Discovery Engine (<a href="https://moogi.co/">moogi.co</a>), powered by GRAKN.AI</figcaption></figure><p>As the year started, we entered the last month of our prototype development deadline. The purpose of our prototype delivery was to demonstrate one of the applications of our knowledge graph technology: a semantic search engine for web-scale applications. So we built Moogi: a film discovery engine, powered by Grakn under the hood (at the time, Grakn still had the old name ‘Mindmaps’). We integrated publicly available movie information from many sources, did some machine learning to generate more content tags, and combined data from the <a href="https://api.guidebox.com/">GuideBox API</a> as well. We also built a distributed cluster for the knowledge graph and a web application for the search engine. We ended up with a discovery engine where you can pretty much find any film released before 2016, with search capabilities, unlike any other movie discovery platform. Most importantly, we only spent six months developing it, all while doing recruitment, developing the knowledge graph prototype, natural language query parser and an ETL (Extraction Transformation and Loading) data pipeline!</p><p>To this date, Moogi is still running live on the internet, even though we have not spent much time maintaining it. You are most welcome to try it out: <a href="https://moogi.co/">https://moogi.co/</a>, and here’s an example query to start with: <em>“action movies filmed in South Africa filmed in the 2000s”</em>.</p><p><em>Thank you </em><a href="https://api.guidebox.com/"><em>GuideBox</em></a><em> for enabling to integrate movie streaming links from all kinds of platforms into our Moogi Knowledge Graph!</em></p><h3>We launched our online platforms</h3><blockquote>From a <a href="https://grakn.ai/slack">chat platform</a> to a <a href="https://discuss.grakn.ai/">discussion forum</a>, a <a href="https://blog.grakn.ai/">blog</a> and a <a href="https://grakn.ai/docs">documentation platform</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nz_3q0JqWqptRNmPJo7aZQ.png" /><figcaption>Grakn Discussion platform (<a href="https://discuss.grakn.ai/">discuss.grakn.ai</a>), Grakn Blog (<a href="https://blog.grakn.ai/">blog.grakn.ai</a>), and Grakn Community Slack (<a href="https://grakn.ai/slack">grakn.ai/slack</a>)</figcaption></figure><p>While the development of our knowledge graph platform was on its way, we started preparing the online platforms to build our open-source community. We wanted to make sure that we have all the communication channels we need to build and help our developers, as well for the community to help each other. It boils down to three types of a platform: a chat platform for lightweight and ongoing and conversation, a discussion forum for in-depth discussions on specific topics, and a blog for us to share our stories. So we went on and used Slack as our <a href="https://grakn.ai/slack">Grakn Community chat</a> platform, built <a href="https://discuss.grakn.ai/">our own discussion forum</a> using Discourse, and integrated Medium as our <a href="https://blog.grakn.ai/">website’s blog</a> as our publishing platform! I am very pleased to see that all three of our platforms are very active and that I consistently find content that I can learn from.</p><p><em>Big thanks to </em><a href="http://www.discourse.org/"><em>Discourse</em></a><em>, </em><a href="https://about.medium.com/"><em>Medium</em></a><em> and </em><a href="https://slack.com/"><em>Slack</em></a><em> for enabling us to have amazing online platforms!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GacWrSYwaIEUqb7BbKxEtg.png" /><figcaption>Grakn’s new website (<a href="https://grakn.ai/">grakn.ai</a>) along with our new Documentation platform (<a href="https://grakn.ai/docs">grakn.ai/docs</a>)</figcaption></figure><p>We also did a makeover on our website to describe our technology better, and added the one most important thing that an open-source technology needs: <a href="http://grakn.ai/docs">a documentation platform</a>! Although it is still in its infancy at the moment, there is much work going on to our documentation platform, and there will be plenty of improvements coming in the next few months!</p><p><em>Thank you to the team behind </em><a href="https://jekyllrb.com/"><em>Jekyll</em></a><em> for building a tool that allowed us to easily integrate our documentation on GitHub to our website!</em></p><h3>We grew to a solid team of 17</h3><blockquote>We reviewed 1400 candidates through a 6 stage recruitment process. We now have a solid team of 17 where we know we can depend on each other.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ICzfopTHgkgyCj55Vg1afA.png" /><figcaption>GRAKN.AI Team, learn more at <a href="https://grakn.ai/about.html">grakn.ai/about</a></figcaption></figure><p>When we started this company a year and a half ago, there was one thing that we decided we will never compromise, and that is the talent of people we bring on board to join the team. So from day one, we set up our own six stage recruitment process. As you can expect, this results in a very low number of engineers passing through to the last round; the passing rate was about 1 out of 100 applicants. Naturally, recruiting becomes a challenge. So we “hacked” our software development framework to also become a <em>distributed recruitment management platform</em> so that we can increase the number applicants we can review and distribute the massive number of recruitment tasks across everyone in the team. By the time we enter the second half of this year, we have already managed to review 1000 engineers from across the world, in addition to the 400 that we reviewed the year before.</p><p>In our interview process, we look not only for engineering skills but also other core competencies such as communication, analytical, design, brainstorming, and interpersonal skills. It is vital to us that our team members are highly motivated and self-driven. After going through our process of building a team of 17, I am proud to say that we have successfully built a team with the criteria we have just described. Everyone also have Masters and PhDs in advanced computing and quantitative disciplines from top universities including Cambridge, Oxford, Imperial, UCL, Edinburgh, and Columbia. However, what makes 2016 special with regards to our team is the fact that we have built a solid relationship with each other, we can always rely on one another, and we can always crack a joke and have fun.</p><p>Personally, I know that I always learn from everyone in the team. Thank you, guys!</p><p>PS: If you want to find out more about our team members, visit <a href="https://grakn.ai/about.html">https://grakn.ai/about</a></p><h3>We scaled our project management framework</h3><blockquote>This year we managed 18 projects and completed over 500 requirements which translated to 9000 work items with a total of 10000 pre-estimated hours!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ii6H1YejUZse8eGzguAW8Q.png" /></figure><p>Our development is quite <a href="https://en.wikipedia.org/wiki/Agile_software_development">Agile</a>, as things change rapidly, and we embrace it. We practice <a href="https://en.wikipedia.org/wiki/Scrum_(software_development)">Scrum</a> as we develop in weekly iterations of sprints. Releases used to happen every two months, but now we release every 2 or 3 weeks. However, we still hold some core values of <a href="https://en.wikipedia.org/wiki/Waterfall_model">Waterfall</a>, as we love the requirements and design phase, except that our <a href="https://en.wikipedia.org/wiki/Requirements_analysis">requirements log</a> is always open, always updated, always reviewed and always feeds into the development iteration. Imagine a continuous design phase of the Waterfall SDLC which feeds into an Agile team who develop in Sprints every week. We also extended the framework to manage non-engineering work.</p><p>Towards the end of this year, we were managing 18 projects and completed over 500 requirements which translated to 9000 work items with a total of 10000 pre-estimated hours! Needless to say, we are very proud of how productive our team has been. It was our team’s ability to plan that enabled us to deliver our technology in just about a year!</p><p><em>Big shout out to </em><a href="https://www.targetprocess.com/"><em>TargetProcess</em></a><em> and </em><a href="https://github.com/"><em>GitHub</em></a><em> for enabling us build a framework that fits our workflow! Thank you!</em></p><h3>We found our new name</h3><blockquote>Grakn stands for a graph of knowledge, Graql is the graph query language for Grakn, and we’re an AI technology. Thus, we’re GRAKN.AI.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_htKuFydbZXWrDQco-FhqQ.png" /></figure><p>As most of you probably know, we used to be called Mindmaps. What we did not consider when we named our company “Mindmaps” was how hard it would be to search for us on Google, as there are so many technologies on the web with the name “Mindmaps”. Some people were also confusing our technology with mindmapping tools. Since we also found out that we could not trademark the name, we knew that we had to find a new name that uniquely describes us.</p><p>Towards the second half of this year, we found that new name. “<em>Grakn”</em> stands for a graph of knowledge (what we turn your data into), and “<em>Graql”</em> is the graph query language (used to query data from/to Grakn). Given that our work is grounded in the field of Knowledge Representation and Reasoning, a subfield of Artificial Intelligence, and the technology applications will also be in the field of applied AI, we decided the name of our technology to be GRAKN.AI. The name also fits well with the new “<em>.ai</em>” domain! If you are wondering what “<em>Grakn Labs</em>” is, it is the incorporation name of our company and how we refer to our office.</p><h3>We released the Grakn!</h3><blockquote>Nine major components of the system built in parallel integrated into one Beta release, 0.1, and refined over nine releases, to 0.9.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GRevLt9ZEMxHrog3xdrUwQ.png" /><figcaption>Graql performing an inference across 5 databases integrated into 1 Grakn knowledge graph. The query looks for drugs that are related to breast cancer through paths between micro RNA (somthing like DNA) and and genes in our body. The query is so simple yet so powerful.</figcaption></figure><p>Once we got the prototype and Moogi completed around April, it was time to build the complete knowledge graph framework, and there were so many components needed to complete the framework!</p><p>There were nine principal components of the system: the Graph API, a query language (Graql), the graph analytics engine, the reasoning engine, a migration system, the database factory, the graph engine/server, the visualisation dashboard and the benchmark dataset generator. Every engineer was in charge of at least one major component, and development of all parts of the system had to happen in parallel.</p><p>These were some of the heaviest days, but also some of the best that we will always remember. For most of us (including me), this was our first open-source product release in the history of our careers. So it was very exhilarating!</p><p>We finally got all components of the stack integrated into one Grakn stack for the first time in September, and we immediately published a 0.1 Beta release! The purpose of the release was to gain some light adoption, user testing, prototyping applications (<a href="https://blog.grakn.ai/">we blogged about them</a>) and getting user feedback.</p><p>As it happens, our open-source adoption for this beta release was a little more than we expected (which I will talk about below). The feedback we received allowed us to iterate on the stack rapidly. Every two weeks we completed significant improvements and released a new version of the stack.</p><p>Grakn is now version 0.9, which we released the week right before Christmas. It is almost feature-complete for production release (1.0) coming very soon, and already much simpler, smarter, faster and prettier than the 0.1 release we made only three months before!</p><p>After about a year of challenging and ambitious engineering, I cannot be prouder of our team for the Grakn release we have accomplished this year!</p><h3>We talked with many enterprises</h3><blockquote>After many demos and feedback, we learnt that companies working on building AI systems more urgently need our technology to simplify their data processing.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ylpf-CWo5F9E3tZD4ZDhiQ.jpeg" /><figcaption>A slide from <a href="http://firstmarkcap.com/team/matt-turck/">Matt Turck</a>’s talk at O’Reilly AI Conference in NYC which we completely relate to — the struggle is real!</figcaption></figure><p>Since we released Grakn Beta in September, we have been attending some excellent conferences around the world, such as O’Reilly AI NYC, ISWC Japan, and AI World SF, as well as plenty of Meetups at home here in London.</p><p>From these events, we met with lots of organisations of many sizes, from startups to enterprise. We have given live demos to many of them, and the feedback has been very positive. One crucial thing that we learned from this feedback is that companies with the most urgent need for our technology are the ones working to build AI applications. Such use cases involve incredibly complex data processing: exactly what Grakn can help simplify. Given this positive, early feedback, and the discussions with enterprises we’ve been having, we are very confident that 2017 will bring big things in terms of enterprise adoption!</p><h3>Our open-source community started growing</h3><blockquote>Since our Beta release 3 months ago, Grakn has been downloaded 813 times! We have 50+ developer community members, 265 twitter followers, 82 Github stars and 25 forks!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*ElA2WGuwKI9b9z7sRMqYfA.png" /><figcaption>Our open-source code repository on Github. Star us if you like us! <a href="https://github.com/graknlabs/grakn">https://github.com/graknlabs/grakn</a></figcaption></figure><p>It is important to remember that Grakn is not a consumer app, like iPhone games or dating apps. Grakn is an enterprise / deep infrastructure; its adoption rate is therefore not straightforwardly comparable to the explosive growth you’d expect to see in a successful consumer app.</p><p>Nevertheless, the response from the open-source community since our Beta release has exceeded all expectations. Since we have been prioritizing rapid, responsive, and robust development in this early stage of community building, we have not yet worked to optimize conversion rates, engage in user testing of our website, or try out some SEO magic; nor have we yet rolled out a complete marketing campaign. However, we see an average of 10 downloads per day. Since our Beta release 3 months ago, Grakn has been downloaded 813 times! We have 50+ developer community members, 265 twitter followers, 82 Github stars and 25 forks! We know this is still the early days, but as a deep infrastructure technology, these numbers way surpassed our expectations for a three months period from our Beta release!</p><h3>Thank you</h3><blockquote>Thank you. This journey would not have been possible without all of you.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b0YOa_gI8yVowlb5r8TUoA.png" /></figure><p>So those are the highlights of the past year here at GRAKN.AI. Reflecting back on them, we cannot help but realise how much joy and how many lessons this year has given us. This year has allowed us to grow at a rate that we have never had before, and all of it was possible because of every single person involved in our journey. The hard work and sacrifice of our team, the encouragement from our family and friends, the advice from our mentors, the feedback from our users, the support of our partners, the relationships with our readers, the friendship of everyone we met along the way, they all mattered a great deal to the growth of ourselves and of our company this past year, and we know that they will continue to matter immensely as we move into 2017.</p><p>Thank you, everyone. Thank you, my Grakn family. This journey would not have been possible without all of you.</p><p><strong><em>To many more great years ahead of us!</em></strong></p><p>PS: If you would like to join our journey next year, please visit <a href="https://grakn.ai/community">https://grakn.ai/community</a> and feel free to get in touch through your preferred platform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e30b66adece3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/grakn-2016-year-in-review-e30b66adece3">GRAKN.AI 2016: Year in Review</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Challenges of Working with a Graph Database]]></title>
            <link>https://medium.com/vaticle/the-challenges-of-working-with-a-graph-database-2a5f9a7c903b?source=rss-5ef03fa74362------2</link>
            <guid isPermaLink="false">https://medium.com/p/2a5f9a7c903b</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Haikal Ryclova-Pribadi]]></dc:creator>
            <pubDate>Sat, 18 Jun 2016 21:07:52 GMT</pubDate>
            <atom:updated>2018-04-11T20:09:43.670Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nCMhNbPplgGOxFy0e_CmrQ.png" /></figure><p>A graph database allows a more natural modelling of data. Its data structure provides the highest level of expressivity and is thus perfect for capturing highly interconnected data in complex domains. It also enables the natural querying of data with high degrees of separation. In the current age of interconnected data, graph databases and graph query languages are pivotal to the evolution of databases.</p><p>In the recent years, we’ve seen an increasing growth of graph databases. Some of the key technologies in the industry are <a href="http://www.neo4j.com/">Neo4J</a>, <a href="http://titan.thinkaurelius.com/">TitanDB</a>, <a href="http://www.blazegraph.com/">BlazeGraph</a>, <a href="http://hypergraphdb.org/">HypergraphDB</a>, <a href="http://orientdb.com/">OrientDB</a>, <a href="http://www.ibm.com/analytics/us/en/technology/cloud-data-services/graph/">IBM Graph</a> and <a href="http://en.wikipedia.org/wiki/Graph_database">the list goes on</a>. Recently, Datastax, a prominent technology provider in the NoSQL space, launched their <a href="http://www.datastax.com/products/datastax-enterprise-graph">DataStax Enterprise Graph</a> database. The development of graph databases in the commercial industry brings a lot of confidence to the future of graph computing and how the field will help revolutionise the database industry.</p><p>However, neither graph computing as a field nor graph databases as a technology are new, but have been around for at least 30 years. So why is it that they are still not the most adopted database?</p><p>We believe the lag in uptake hinges on the fact that developing on a graph database requires you to understand too many low-level implementation details of graph computing. As a graph database user, you need to overcome plenty of prerequisite challenges and go through a steep learning curve before you can use the technology optimally.</p><p>In this article, we’ll talk about the top three challenges of working with current graph databases and how can we overcome these challenges.</p><h3>1. Modelling Highly Interconnected Data</h3><p>Due to the high level of expressivity that graph databases provide, modelling a domain on a graph is not easy, and is equivalent to modelling knowledge, i.e. ontology engineering.</p><p>Specialist graph data engineers are needed to model a graph structure. This approach, however, is not scalable for widespread adoption. Instead, what is needed is a system which would allow any engineer to easily model their domain on a graph, without having to be proficient in ontology engineering or be an expert in the underlying graph data structure.</p><h3>2. Maintaining Consistency of Data</h3><p>The job is not done even when an ontology is derived to model the domain and govern the structure of the graph database. It is essential that data loaded into the graph database complies with the ontology. The data model defined for the domain, as described above, does not act as a “schema” to which the graph database adheres. Graph databases, like other NoSQL databases, delegate adherence to a schema to the application system.</p><p>For example, if you have modelled:</p><ul><li>a “Company” that can be related to a “Person” through an “Employment” relationship</li><li>a “Person” that can be related to an “Cat” through a “Has-Pet” relationship</li></ul><p>You really don’t want the graph database to allow storage of data that says: a cat named “Kitty” to be “employed” by the company “Apple Inc.”.</p><p>Although developing such a system for one particular domain is feasible, it take significant effort. It is yet more challenging to deliver a system that is generic enough to guarantee consistency of data with regards to the model, but that maintains the highest level of expressivity possible.</p><p>Many would argue that there is no such thing as data without a schema, at least if you want to extract significant value from it. A schema is either explicitly defined (such as with relational databases), or it is implicit at the database user level. Given the degree of complexity of highly interconnected data captured by graphs, the lack of data consistency becomes another hurdle in getting the world to adopt graph databases confidently.</p><h3>3. Writing the Graph Queries Itself</h3><p>Let’s say that, at this point, you have managed to model a domain, as well as develop a system that will govern the consistency of data. The next step is to develop graph queries that will interrogate the graph database — this task also has its challenges. When developing graph queries, although you are provided with the power of querying high degrees of separation between data, you need to be explicit in defining the path to traverse between data instances. Given that your data model governs the paths between your data instances, you now have to design your queries specific to the way that you defined your model.</p><p>What makes this sort of querying challenging is that you may not have modelled your data in the most generic, consistent and conceptually correct model, (e.g. sometimes you defined a relationship as a node, other times as an edge). Consequently, the graph queries that you write are also not generic, and thus not reusable between problems, let alone across domains. Every question that you would like to ask the graph requires a custom graph query, written based on your custom domain model, which may or may not provide the most optimal path for querying your data. Therefore, your graph data engineer is not able to abstract the graph query into functions that would take your user’s input as an argument, and reuse those functions across multiple problem use cases.</p><p>Writing graph queries is already a challenging task as you need to understand graph algorithms and data structures. With the additional challenge of not being able to abstract and reuse your graph queries to the point where you can just focus on your problem domain, adoption of graph databases become much slower than what it should be.</p><h3>How can we overcome these challenges?</h3><p>Technology is invented for the sole purpose of exploiting its strengths to help solve difficult problems in this world. The shape or form it is delivered in is irrelevant; thus, it should not get in the way of its potential purpose.</p><p>As we have described, in order to adopt graph databases, the need to understand the notion of vertices and edges, how they are used to capture data and details of the graph algorithms required to interact efficiently with them, is a huge burden that hinders the uptake.</p><p>To solve this challenge, we have abstracted the nitty gritty of a graph database by developing a more <a href="https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning">Knowledge Representation and Reasoning</a> database system, transforming it into a knowledge graph.</p><p>A knowledge graph is a <a href="https://en.wikipedia.org/wiki/Knowledge_base">knowledge base</a> in the form of a graph. The advantage of using a knowledge graph for data storage and analysis is that it lets you focus on modelling your domain expressively and writing queries without having to learn graph computing/algorithms, while trusting that the database will guarantee the data consistency with respect to their model.</p><p>A knowledge graph abstracts the low-level implementation details of graph computing and lets you adopt the technology without a steep learning curve.</p><p>So the next questions are:<br>1. How exactly does a knowledge graph alleviate the pain points of working with a graph database?<br>2. What are the advantages of a knowledge graph other than better delivering the strengths of graph databases to the world?</p><p>I’ll talk about these questions in detail in separate articles. Stay tuned.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a5f9a7c903b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vaticle/the-challenges-of-working-with-a-graph-database-2a5f9a7c903b">The Challenges of Working with a Graph Database</a> was originally published in <a href="https://medium.com/vaticle">TypeDB</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>